ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/leyyin/stk-code into leyyin

Browse Source
This commit is contained in:
hiker 2014-08-08 11:10:56 +10:00
commit f39e22e442
54 changed files with 792 additions and 735 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
data/shaders/billboard.vert
View File

@ -2,16 +2,15 @@ uniform mat4 ModelViewMatrix;
uniform vec3 Position;
uniform vec2 Size;
#if __VERSION__ >= 130
#if __VERSION__ >= 330
layout(location = 0) in vec2 Corner;
layout(location = 3) in vec2 Texcoord;
#else
in vec2 Corner;
in vec2 Texcoord;
out vec2 uv;
#else
attribute vec2 Corner;
attribute vec2 Texcoord;
varying vec2 uv;
#endif
out vec2 uv;
void main(void)
{

14
data/shaders/object_unlit.frag
View File

@ -1,17 +1,13 @@
uniform sampler2D tex;
#if __VERSION__ >= 130
in vec2 uv;
in vec4 color;
out vec4 FragColor;
#else
varying vec2 uv;
#define FragColor gl_FragColor
#endif
void main(void)
{
vec4 color = texture(tex, uv);
if (color.a < 0.5) discard;
FragColor = vec4(color.xyz, 1.);
vec4 col = texture(tex, uv);
col.xyz *= pow(color.xyz, vec3(2.2));
if (col.a < 0.5) discard;
FragColor = vec4(col.xyz, 1.);
}

13
data/shaders/objectref_pass2.frag
View File

@ -1,19 +1,16 @@
uniform sampler2D Albedo;
#if __VERSION__ >= 130
in vec2 uv;
in vec4 color;
out vec4 FragColor;
#else
varying vec2 uv;
#define FragColor gl_FragColor
#endif
vec3 getLightFactor(float specMapValue);
void main(void)
{
vec4 color = texture(Albedo, uv);
if (color.a < 0.5) discard;
vec4 col = texture(Albedo, uv);
col.xyz *= pow(color.xyz, vec3(2.2));
if (col.a * color.a < 0.5) discard;
vec3 LightFactor = getLightFactor(1.);
FragColor = vec4(color.xyz * LightFactor, 1.);
FragColor = vec4(col.xyz * LightFactor, 1.);
}

3
src/addons/news_manager.cpp
View File

@ -138,6 +138,7 @@ void* NewsManager::downloadNews(void *obj)
HTTPRequest *download_req = new HTTPRequest("news.xml");
download_req->setAddonsURL("news.xml");
// Initialise the online portion of the addons manager.
if(UserConfigParams::logAddons())
Log::info("addons", "Downloading news.");
@ -150,10 +151,12 @@ void* NewsManager::downloadNews(void *obj)
// that a redirect went wrong, or a wrong/incorrect
// address somehow made its way into the config file.
delete download_req;
// We need a new object, since the state of the old
// download request is now done.
download_req = new HTTPRequest("news.xml");
UserConfigParams::m_server_addons.revertToDefaults();
// make sure the new server address is actually used
download_req->setAddonsURL("news.xml");
download_req->executeNow();

4
src/challenges/challenge_data.hpp
View File

@ -42,8 +42,8 @@ public:
UNLOCK_GP,
UNLOCK_MODE,
UNLOCK_KART,
UNLOCK_DIFFICULTY}
;
UNLOCK_DIFFICULTY
};
// ------------------------------------------------------------------------
class UnlockableFeature
{

4
src/config/player_manager.hpp
View File

@ -156,8 +156,4 @@ public:
} // increaseAchievement
// ------------------------------------------------------------------------
}; // PlayerManager
#endif
/*EOF*/

2
src/config/player_profile.hpp
View File

@ -127,7 +127,7 @@ public:
/** Abstract virtual classes, to be implemented by the OnlinePlayer. */
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &php_script = "") const = 0;
const std::string &url_path = "") const = 0;
virtual uint32_t getOnlineId() const = 0;
virtual PlayerProfile::OnlineState getOnlineState() const = 0;
virtual Online::OnlineProfile* getProfile() const = 0;

2
src/graphics/render.cpp
View File

@ -383,6 +383,8 @@ void IrrDriver::renderScene(scene::ICameraSceneNode * const camnode, unsigned po
if (!UserConfigParams::m_dynamic_lights && !forceRTT)
{
glDisable(GL_FRAMEBUFFER_SRGB);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
return;
}

40
src/graphics/render_geometry.cpp
View File

@ -212,9 +212,9 @@ void IrrDriver::renderSolidFirstPass()
std::vector<TexUnit> object_pass1_texunits = TexUnits(TexUnit(MeshShader::ObjectPass1Shader::getInstance()->TU_tex, true) );
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatDefault::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatSphereMap::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_STANDARD, 2, 1>(object_pass1_texunits, ListMatUnlit::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatDetails::Arguments);
renderMeshes1stPass<MeshShader::ObjectPass1Shader, video::EVT_2TCOORDS, 2, 1>(object_pass1_texunits, ListMatSplatting::Arguments);
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD, 3, 2, 1>(object_pass1_texunits, ListMatUnlit::Arguments);
renderMeshes1stPass<MeshShader::ObjectRefPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::ObjectRefPass1Shader::getInstance()->TU_tex, true)), ListMatAlphaRef::Arguments);
renderMeshes1stPass<MeshShader::GrassPass1Shader, video::EVT_STANDARD, 3, 2, 1>(TexUnits(TexUnit(MeshShader::GrassPass1Shader::getInstance()->TU_tex, true)), ListMatGrass::Arguments);
renderMeshes1stPass<MeshShader::NormalMapShader, video::EVT_TANGENTS, 2, 1>(TexUnits(
@ -416,8 +416,8 @@ void IrrDriver::renderTransparent()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
glUseProgram(MeshShader::DisplaceMaskShaderInstance->Program);
MeshShader::DisplaceMaskShaderInstance->setUniforms(AbsoluteTransformation);
glUseProgram(MeshShader::DisplaceMaskShader::getInstance()->Program);
MeshShader::DisplaceMaskShader::getInstance()->setUniforms(AbsoluteTransformation);
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex);
}
@ -435,12 +435,12 @@ void IrrDriver::renderTransparent()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
// Render the effect
setTexture(MeshShader::DisplaceShaderInstance->TU_displacement_tex, getTextureGLuint(displaceTex), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_mask_tex, irr_driver->getRenderTargetTexture(RTT_TMP1), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_color_tex, irr_driver->getRenderTargetTexture(RTT_COLOR), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR, true);
glUseProgram(MeshShader::DisplaceShaderInstance->Program);
MeshShader::DisplaceShaderInstance->setUniforms(AbsoluteTransformation,
setTexture(MeshShader::DisplaceShader::getInstance()->TU_displacement_tex, getTextureGLuint(displaceTex), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_mask_tex, irr_driver->getRenderTargetTexture(RTT_TMP1), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_color_tex, irr_driver->getRenderTargetTexture(RTT_COLOR), GL_LINEAR, GL_LINEAR, true);
setTexture(MeshShader::DisplaceShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR, true);
glUseProgram(MeshShader::DisplaceShader::getInstance()->Program);
MeshShader::DisplaceShader::getInstance()->setUniforms(AbsoluteTransformation,
core::vector2df(cb->getDirX(), cb->getDirY()),
core::vector2df(cb->getDir2X(), cb->getDir2Y()));
@ -490,9 +490,9 @@ struct shadow_custom_unroll_args<N, List...>
};
template<typename T, enum E_VERTEX_TYPE VertexType, int...List, typename... Args>
void renderShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
void renderShadow(const std::vector<GLuint> TextureUnits, const std::vector<STK::Tuple<GLMesh *, core::matrix4, Args...> >&t)
{
glUseProgram(Shader->Program);
glUseProgram(T::getInstance()->Program);
glBindVertexArray(getVAO(VertexType));
for (unsigned i = 0; i < t.size(); i++)
{
@ -503,7 +503,7 @@ void renderShadow(const T *Shader, const std::vector<GLuint> TextureUnits, const
setTexture(TextureUnits[j], getTextureGLuint(mesh->textures[j]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
}
shadow_custom_unroll_args<List...>::template exec<T>(Shader, t[i]);
shadow_custom_unroll_args<List...>::template exec<T>(T::getInstance(), t[i]);
}
}
@ -551,14 +551,14 @@ void IrrDriver::renderShadows()
m_scene_manager->drawAll(scene::ESNRP_SOLID);
std::vector<GLuint> noTexUnits;
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatDefault::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatSphereMap::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatUnlit::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatDetails::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatSplatting::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_TANGENTS, 1>(MeshShader::ShadowShaderInstance, noTexUnits, ListMatNormalMap::Arguments);
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(MeshShader::RefShadowShaderInstance, std::vector<GLuint>{ MeshShader::RefShadowShaderInstance->TU_tex }, ListMatAlphaRef::Arguments);
renderShadow<MeshShader::GrassShadowShader, EVT_STANDARD, 3, 1>(MeshShader::GrassShadowShaderInstance, std::vector<GLuint>{ MeshShader::GrassShadowShaderInstance->TU_tex }, ListMatGrass::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(noTexUnits, ListMatDefault::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_STANDARD, 1>(noTexUnits, ListMatSphereMap::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(noTexUnits, ListMatDetails::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_2TCOORDS, 1>(noTexUnits, ListMatSplatting::Arguments);
renderShadow<MeshShader::ShadowShader, EVT_TANGENTS, 1>(noTexUnits, ListMatNormalMap::Arguments);
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(std::vector<GLuint>{ MeshShader::RefShadowShader::getInstance()->TU_tex }, ListMatAlphaRef::Arguments);
renderShadow<MeshShader::RefShadowShader, EVT_STANDARD, 1>(std::vector<GLuint>{ MeshShader::RefShadowShader::getInstance()->TU_tex }, ListMatUnlit::Arguments);
renderShadow<MeshShader::GrassShadowShader, EVT_STANDARD, 3, 1>(std::vector<GLuint>{ MeshShader::GrassShadowShader::getInstance()->TU_tex }, ListMatGrass::Arguments);
glDisable(GL_POLYGON_OFFSET_FILL);

8
src/graphics/render_skybox.cpp
View File

@ -504,6 +504,14 @@ void IrrDriver::generateDiffuseCoefficients()
testSH(sh_rgba, sh_w, sh_h, blueSHCoeff, greenSHCoeff, redSHCoeff);
// Diffuse env map is x 0.25, compensate
for (unsigned i = 0; i < 9; i++)
{
blueSHCoeff[i] *= 4;
greenSHCoeff[i] *= 4;
redSHCoeff[i] *= 4;
}
for (unsigned i = 0; i < 6; i++)
delete[] sh_rgba[i];
}

102
src/graphics/shaders.cpp
View File

@ -404,19 +404,9 @@ void Shaders::loadShaders()
FullScreenShader::MLAAColorEdgeDetectionSHader::init();
FullScreenShader::MLAABlendWeightSHader::init();
FullScreenShader::MLAAGatherSHader::init();
MeshShader::ColorizeShader::init();
MeshShader::BubbleShader::init();
MeshShader::BillboardShader::init();
LightShader::PointLightShader::init();
MeshShader::DisplaceShaderInstance = new MeshShader::DisplaceShader();
MeshShader::DisplaceMaskShaderInstance = new MeshShader::DisplaceMaskShader();
MeshShader::ShadowShaderInstance = new MeshShader::ShadowShader();
MeshShader::RSMShader::init();
MeshShader::InstancedShadowShaderInstance = new MeshShader::InstancedShadowShader();
MeshShader::RefShadowShaderInstance = new MeshShader::RefShadowShader();
MeshShader::InstancedRefShadowShaderInstance = new MeshShader::InstancedRefShadowShader();
MeshShader::GrassShadowShaderInstance = new MeshShader::GrassShadowShader();
MeshShader::InstancedGrassShadowShaderInstance = new MeshShader::InstancedGrassShadowShader();
MeshShader::SkyboxShader::init();
MeshShader::ViewFrustrumShader::init();
ParticleShader::FlipParticleRender::init();
@ -713,7 +703,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str());
AssignUniforms("ModelMatrix", "TextureMatrix", "ambient");
AssignUniforms("ModelMatrix", "TextureMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
@ -735,7 +725,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/object_pass2.frag").c_str());
AssignUniforms("ambient");
AssignUniforms();
TU_Albedo = 3;
AssignTextureUnit(Program,
@ -757,11 +747,11 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str());
AssignUniforms("ambient");
AssignUniforms();
TU_Albedo = 3;
AssignTextureUnit(Program,
TexUnit(0, "DiffuseMap"),
TexUnit(0, "DiffuseMap"),
TexUnit(1, "SpecularMap"),
TexUnit(2, "SSAO"),
TexUnit(TU_Albedo, "Albedo")
@ -777,7 +767,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/detailledobject_pass2.frag").c_str());
AssignUniforms("ModelMatrix", "ambient");
AssignUniforms("ModelMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
TU_Albedo = 3;
@ -813,7 +803,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectref_pass2.frag").c_str());
AssignUniforms("ModelMatrix", "TextureMatrix", "ambient");
AssignUniforms("ModelMatrix", "TextureMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
@ -834,7 +824,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/grass_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/grass_pass2.frag").c_str());
AssignUniforms("ModelMatrix", "windDir", "ambient");
AssignUniforms("ModelMatrix", "windDir");
TU_Albedo = 3;
AssignTextureUnit(Program,
@ -852,7 +842,7 @@ namespace MeshShader
GL_VERTEX_SHADER, file_manager->getAsset("shaders/instanced_grass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/grass_pass2.frag").c_str());
AssignUniforms("windDir", "SunDir", "ambient");
AssignUniforms("windDir", "SunDir");
TU_Albedo = 3;
TU_dtex = 4;
@ -875,7 +865,7 @@ namespace MeshShader
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getLightFactor.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/utils/getPosFromUVDepth.frag").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/objectpass_spheremap.frag").c_str());
AssignUniforms("ModelMatrix", "InverseModelMatrix", "ambient");
AssignUniforms("ModelMatrix", "InverseModelMatrix");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
@ -895,7 +885,7 @@ namespace MeshShader
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/splatting.frag").c_str());
AssignUniforms("ModelMatrix", "ambient");
AssignUniforms("ModelMatrix");
TU_tex_layout = 3;
TU_tex_detail0 = 4;
TU_tex_detail1 = 5;
@ -968,66 +958,32 @@ namespace MeshShader
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
GLuint BillboardShader::Program;
GLuint BillboardShader::attrib_corner;
GLuint BillboardShader::attrib_texcoord;
GLuint BillboardShader::uniform_MV;
GLuint BillboardShader::uniform_P;
GLuint BillboardShader::uniform_tex;
GLuint BillboardShader::uniform_Position;
GLuint BillboardShader::uniform_Size;
void BillboardShader::init()
BillboardShader::BillboardShader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/billboard.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/billboard.frag").c_str());
attrib_corner = glGetAttribLocation(Program, "Corner");
attrib_texcoord = glGetAttribLocation(Program, "Texcoord");
uniform_MV = glGetUniformLocation(Program, "ModelViewMatrix");
uniform_P = glGetUniformLocation(Program, "ProjectionMatrix");
uniform_Position = glGetUniformLocation(Program, "Position");
uniform_Size = glGetUniformLocation(Program, "Size");
uniform_tex = glGetUniformLocation(Program, "tex");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
AssignUniforms("ModelViewMatrix", "ProjectionMatrix", "Position", "Size");
TU_tex = 0;
AssignTextureUnit(Program, TexUnit(TU_tex, "tex"));
}
void BillboardShader::setUniforms(const core::matrix4 &ModelViewMatrix,
const core::matrix4 &ProjectionMatrix,
const core::vector3df &Position,
const core::dimension2d<float> &size,
unsigned TU_tex)
{
glUniformMatrix4fv(uniform_MV, 1, GL_FALSE, ModelViewMatrix.pointer());
glUniformMatrix4fv(uniform_P, 1, GL_FALSE, ProjectionMatrix.pointer());
glUniform3f(uniform_Position, Position.X, Position.Y, Position.Z);
glUniform2f(uniform_Size, size.Width, size.Height);
glUniform1i(uniform_tex, TU_tex);
}
GLuint ColorizeShader::Program;
GLuint ColorizeShader::uniform_MM;
GLuint ColorizeShader::uniform_col;
void ColorizeShader::init()
ColorizeShader::ColorizeShader()
{
Program = LoadProgram(
GL_VERTEX_SHADER, file_manager->getAsset("shaders/object_pass.vert").c_str(),
GL_FRAGMENT_SHADER, file_manager->getAsset("shaders/colorize.frag").c_str());
uniform_MM = glGetUniformLocation(Program, "ModelMatrix");
uniform_col = glGetUniformLocation(Program, "col");
AssignUniforms("ModelMatrix", "col");
GLuint uniform_ViewProjectionMatrixesUBO = glGetUniformBlockIndex(Program, "MatrixesData");
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
void ColorizeShader::setUniforms(const core::matrix4 &ModelMatrix, float r, float g, float b)
{
if (irr_driver->needUBOWorkaround())
bypassUBO(Program);
glUniformMatrix4fv(uniform_MM, 1, GL_FALSE, ModelMatrix.pointer());
glUniform3f(uniform_col, r, g, b);
}
ShadowShader::ShadowShader()
{
// Geometry shader needed
@ -1051,8 +1007,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
ShadowShader *ShadowShaderInstance;
GLuint RSMShader::Program;
GLuint RSMShader::uniform_MM;
GLuint RSMShader::uniform_RSMMatrix;
@ -1100,8 +1054,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
InstancedShadowShader *InstancedShadowShaderInstance;
RefShadowShader::RefShadowShader()
{
// Geometry shader needed
@ -1128,8 +1080,6 @@ namespace MeshShader
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
}
RefShadowShader *RefShadowShaderInstance;
InstancedRefShadowShader::InstancedRefShadowShader()
{
// Geometry shader needed
@ -1156,8 +1106,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
InstancedRefShadowShader *InstancedRefShadowShaderInstance;
GrassShadowShader::GrassShadowShader()
{
// Geometry shader needed
@ -1184,8 +1132,6 @@ namespace MeshShader
AssignTextureUnit(Program, { TexUnit(TU_tex, "tex") });
}
GrassShadowShader *GrassShadowShaderInstance;
InstancedGrassShadowShader::InstancedGrassShadowShader()
{
// Geometry shader needed
@ -1214,8 +1160,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
InstancedGrassShadowShader *InstancedGrassShadowShaderInstance;
DisplaceMaskShader::DisplaceMaskShader()
{
Program = LoadProgram(
@ -1227,8 +1171,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
DisplaceMaskShader *DisplaceMaskShaderInstance;
DisplaceShader::DisplaceShader()
{
@ -1250,8 +1192,6 @@ namespace MeshShader
glUniformBlockBinding(Program, uniform_ViewProjectionMatrixesUBO, 0);
}
DisplaceShader *DisplaceShaderInstance;
GLuint SkyboxShader::Program;
GLuint SkyboxShader::attrib_position;
GLuint SkyboxShader::uniform_MM;

101
src/graphics/shaders.hpp
View File

@ -94,6 +94,13 @@ struct UniformHelper
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, const core::dimension2df &v, Args... arg)
{
glUniform2fWraper(uniforms[N], v.Width, v.Height);
setUniformsHelper<N + 1>(uniforms, arg...);
}
template<unsigned N = 0, typename... Args>
static void setUniformsHelper(const std::vector<GLuint> &uniforms, float f, Args... arg)
{
@ -106,51 +113,28 @@ struct UniformHelper
void bypassUBO(GLuint Program);
GLuint getUniformLocation(GLuint program, const char* name);
template<typename... Args>
class ShaderHelper
{
protected:
std::vector<GLuint> uniforms;
void AssignUniforms(const char* name)
{
uniforms.push_back(getUniformLocation(Program, name));
}
template<typename... T>
void AssignUniforms(const char* name, T... rest)
{
uniforms.push_back(getUniformLocation(Program, name));
AssignUniforms(rest...);
}
public:
GLuint Program;
void setUniforms(const Args & ... args) const
{
if (needsUBO())
bypassUBO(Program);
UniformHelper::setUniformsHelper(uniforms, args...);
}
};
template<typename T, typename... Args>
class ShaderHelperSingleton : public Singleton<T>
{
protected:
std::vector<GLuint> uniforms;
void AssignUniforms(const char* name)
void AssignUniforms_impl()
{
uniforms.push_back(getUniformLocation(Program, name));
}
template<typename... U>
void AssignUniforms(const char* name, U... rest)
void AssignUniforms_impl(const char* name, U... rest)
{
uniforms.push_back(getUniformLocation(Program, name));
AssignUniforms(rest...);
AssignUniforms_impl(rest...);
}
template<typename... U>
void AssignUniforms(U... rest)
{
static_assert(sizeof...(rest) == sizeof...(Args), "Count of Uniform's name mismatch");
AssignUniforms_impl(rest...);
}
public:
@ -326,36 +310,27 @@ public:
TransparentFogShader();
};
class BillboardShader
class BillboardShader : public ShaderHelperSingleton<BillboardShader, core::matrix4, core::matrix4, core::vector3df, core::dimension2df>
{
public:
static GLuint Program;
static GLuint attrib_corner, attrib_texcoord;
static GLuint uniform_MV, uniform_P, uniform_tex, uniform_Position, uniform_Size;
GLuint TU_tex;
static void init();
static void setUniforms(const core::matrix4 &ModelViewMatrix, const core::matrix4 &ProjectionMatrix, const core::vector3df &Position, const core::dimension2d<float> &size, unsigned TU_tex);
BillboardShader();
};
class ColorizeShader
class ColorizeShader : public ShaderHelperSingleton<ColorizeShader, core::matrix4, video::SColorf>
{
public:
static GLuint Program;
static GLuint uniform_MM, uniform_col;
static void init();
static void setUniforms(const core::matrix4 &ModelMatrix, float r, float g, float b);
ColorizeShader();
};
class ShadowShader : public ShaderHelper<core::matrix4>
class ShadowShader : public ShaderHelperSingleton<ShadowShader, core::matrix4>
{
public:
ShadowShader();
};
extern ShadowShader *ShadowShaderInstance;
class RSMShader
{
public:
@ -367,61 +342,47 @@ public:
static void setUniforms(const core::matrix4 &RSMMatrix, const core::matrix4 &ModelMatrix);
};
class InstancedShadowShader : public ShaderHelper<>
class InstancedShadowShader : public ShaderHelperSingleton<InstancedShadowShader>
{
public:
InstancedShadowShader();
};
extern InstancedShadowShader *InstancedShadowShaderInstance;
class RefShadowShader : public ShaderHelper<core::matrix4>
class RefShadowShader : public ShaderHelperSingleton<RefShadowShader, core::matrix4>
{
public:
GLuint TU_tex;
RefShadowShader();
};
extern RefShadowShader *RefShadowShaderInstance;
class InstancedRefShadowShader : public ShaderHelper<>
class InstancedRefShadowShader : public ShaderHelperSingleton<InstancedRefShadowShader>
{
public:
GLuint TU_tex;
InstancedRefShadowShader();
};
extern InstancedRefShadowShader *InstancedRefShadowShaderInstance;
class GrassShadowShader : public ShaderHelper<core::matrix4, core::vector3df>
class GrassShadowShader : public ShaderHelperSingleton<GrassShadowShader, core::matrix4, core::vector3df>
{
public:
GLuint TU_tex;
GrassShadowShader();
};
extern GrassShadowShader *GrassShadowShaderInstance;
class InstancedGrassShadowShader : public ShaderHelper<core::vector3df>
class InstancedGrassShadowShader : public ShaderHelperSingleton<InstancedGrassShadowShader, core::vector3df>
{
public:
GLuint TU_tex;
InstancedGrassShadowShader();
};
extern InstancedGrassShadowShader *InstancedGrassShadowShaderInstance;
class DisplaceMaskShader : public ShaderHelper<core::matrix4>
class DisplaceMaskShader : public ShaderHelperSingleton<DisplaceMaskShader, core::matrix4>
{
public:
DisplaceMaskShader();
};
extern DisplaceMaskShader *DisplaceMaskShaderInstance;
class DisplaceShader : public ShaderHelper<core::matrix4, core::vector2df, core::vector2df>
class DisplaceShader : public ShaderHelperSingleton<DisplaceShader, core::matrix4, core::vector2df, core::vector2df>
{
public:
GLuint TU_displacement_tex, TU_mask_tex, TU_color_tex, TU_tex;
@ -429,8 +390,6 @@ public:
DisplaceShader();
};
extern DisplaceShader *DisplaceShaderInstance;
class SkyboxShader
{
public:

8
src/graphics/stk_text_billboard.cpp
View File

@ -29,7 +29,6 @@ STKTextBillboard::STKTextBillboard(core::stringw text, gui::ScalableFont* font,
createGLMeshes();
Mesh->drop();
//setAutomaticCulling(0);
setReloadEachFrame(true); // FIXME: should not need that!!
updateAbsolutePosition();
}
@ -93,7 +92,7 @@ scene::IMesh* STKTextBillboard::getTextMesh(core::stringw text, gui::ScalableFon
{
buffer = new scene::SMeshBuffer();
buffer->getMaterial().setTexture(0, m_chars[i].m_texture);
buffer->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
buffer->getMaterial().MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
buffers[m_chars[i].m_texture] = buffer;
}
else
@ -148,7 +147,7 @@ scene::IMesh* STKTextBillboard::getTextMesh(core::stringw text, gui::ScalableFon
map_itr->second->drop();
}
getMaterial(0).MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
getMaterial(0).MaterialType = irr_driver->getShader(ES_OBJECT_UNLIT);
return Mesh;
}
@ -157,13 +156,14 @@ void STKTextBillboard::OnRegisterSceneNode()
{
if (IsVisible)
{
SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
scene::ICameraSceneNode* curr_cam = irr_driver->getSceneManager()->getActiveCamera();
core::vector3df cam_pos = curr_cam->getPosition();
core::vector3df text_pos = this->getAbsolutePosition();
float angle = atan2(text_pos.X - cam_pos.X, text_pos.Z - cam_pos.Z);
this->setRotation(core::vector3df(0.0f, angle * 180.0f / M_PI, 0.0f));
updateAbsolutePosition();
}
ISceneNode::OnRegisterSceneNode();

2
src/graphics/stkanimatedmesh.cpp
View File

@ -151,7 +151,7 @@ void STKAnimatedMesh::render()
pushVector(ListMatDetails::Arguments, mesh, AbsoluteTransformation, invmodel, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterial[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY, mesh->TextureMatrix);
return;
}

12
src/graphics/stkbillboard.cpp
View File

@ -13,10 +13,10 @@ static void createbillboardvao()
glGenVertexArrays(1, &billboardvao);
glBindVertexArray(billboardvao);
glBindBuffer(GL_ARRAY_BUFFER, SharedObject::billboardvbo);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_corner);
glEnableVertexAttribArray(MeshShader::BillboardShader::attrib_texcoord);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_corner, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(MeshShader::BillboardShader::attrib_texcoord, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(3);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), 0);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (GLvoid*) (2 * sizeof(float)));
glBindVertexArray(0);
}
@ -50,8 +50,8 @@ void STKBillboard::render()
compressTexture(tex, true, true);
GLuint texid = getTextureGLuint(tex);
setTexture(0, texid, GL_LINEAR, GL_LINEAR);
glUseProgram(MeshShader::BillboardShader::Program);
MeshShader::BillboardShader::setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size, 0);
glUseProgram(MeshShader::BillboardShader::getInstance()->Program);
MeshShader::BillboardShader::getInstance()->setUniforms(irr_driver->getViewMatrix(), irr_driver->getProjMatrix(), pos, Size);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindVertexArray(0);
return;

16
src/graphics/stkinstancedscenenode.cpp
View File

@ -156,7 +156,7 @@ static void drawShadowDefault(GLMesh &mesh, size_t instance_count)
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::InstancedShadowShaderInstance->setUniforms();
MeshShader::InstancedShadowShader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
@ -185,8 +185,8 @@ static void drawShadowAlphaRefTexture(GLMesh &mesh, size_t instance_count)
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedRefShadowShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedRefShadowShaderInstance->setUniforms();
setTexture(MeshShader::InstancedRefShadowShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedRefShadowShader::getInstance()->setUniforms();
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
@ -200,8 +200,8 @@ static void drawShadowGrass(GLMesh &mesh, const core::vector3df &windDir, size_t
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
setTexture(MeshShader::InstancedGrassShadowShaderInstance->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassShadowShaderInstance->setUniforms(windDir);
setTexture(MeshShader::InstancedGrassShadowShader::getInstance()->TU_tex, getTextureGLuint(mesh.textures[0]), GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, true);
MeshShader::InstancedGrassShadowShader::getInstance()->setUniforms(windDir);
glBindVertexArray(mesh.vao_shadow_pass);
glDrawElementsInstanced(ptype, count, itype, 0, 4 * instance_count);
@ -356,17 +356,17 @@ void STKInstancedSceneNode::render()
if (irr_driver->getPhase() == SHADOW_PASS)
{
if (!MeshSolidMaterial[MAT_DEFAULT].empty())
glUseProgram(MeshShader::InstancedShadowShaderInstance->Program);
glUseProgram(MeshShader::InstancedShadowShader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_DEFAULT].size(); i++)
drawShadowDefault(*MeshSolidMaterial[MAT_DEFAULT][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_ALPHA_REF].empty())
glUseProgram(MeshShader::InstancedRefShadowShaderInstance->Program);
glUseProgram(MeshShader::InstancedRefShadowShader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_ALPHA_REF].size(); i++)
drawShadowAlphaRefTexture(*MeshSolidMaterial[MAT_ALPHA_REF][i], instance_pos.size() / 9);
if (!MeshSolidMaterial[MAT_GRASS].empty())
glUseProgram(MeshShader::InstancedGrassShadowShaderInstance->Program);
glUseProgram(MeshShader::InstancedGrassShadowShader::getInstance()->Program);
for (unsigned i = 0; i < MeshSolidMaterial[MAT_GRASS].size(); i++)
drawShadowGrass(*MeshSolidMaterial[MAT_GRASS][i], windDir, instance_pos.size() / 9);
return;

2
src/graphics/stkmesh.cpp
View File

@ -298,7 +298,7 @@ std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> >
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatSphereMap::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatDetails::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::vector3df> > ListMatGrass::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListMatUnlit::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatUnlit::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > ListMatSplatting::Arguments;
std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > ListMatNormalMap::Arguments;

2
src/graphics/stkmesh.hpp
View File

@ -98,7 +98,7 @@ public:
class ListMatUnlit
{
public:
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4> > Arguments;
static std::vector<STK::Tuple<GLMesh *, core::matrix4, core::matrix4, core::matrix4> > Arguments;
};
class ListMatDetails

6
src/graphics/stkmeshscenenode.cpp
View File

@ -142,7 +142,7 @@ void STKMeshSceneNode::drawGlow(const GLMesh &mesh)
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
MeshShader::ColorizeShader::setUniforms(AbsoluteTransformation, cb->getRed(), cb->getGreen(), cb->getBlue());
MeshShader::ColorizeShader::getInstance()->setUniforms(AbsoluteTransformation, video::SColorf(cb->getRed(), cb->getGreen(), cb->getBlue()));
glDrawElementsBaseVertex(ptype, count, itype, (GLvoid *)mesh.vaoOffset, mesh.vaoBaseVertex);
}
@ -265,7 +265,7 @@ void STKMeshSceneNode::render()
pushVector(ListMatGrass::Arguments, mesh, AbsoluteTransformation, invmodel, windDir);
for_in(mesh, MeshSolidMaterials[MAT_UNLIT])
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY);
pushVector(ListMatUnlit::Arguments, mesh, AbsoluteTransformation, core::matrix4::EM4CONST_IDENTITY, mesh->TextureMatrix);
for_in(mesh, MeshSolidMaterials[MAT_SPLATTING])
pushVector(ListMatSplatting::Arguments, mesh, AbsoluteTransformation, invmodel);
@ -312,7 +312,7 @@ void STKMeshSceneNode::render()
if (irr_driver->getPhase() == GLOW_PASS)
{
glUseProgram(MeshShader::ColorizeShader::Program);
glUseProgram(MeshShader::ColorizeShader::getInstance()->Program);
for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);

7
src/network/protocols/get_peer_address.cpp
View File

@ -45,9 +45,8 @@ void GetPeerAddress::asynchronousUpdate()
if (m_state == NONE)
{
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "get",
"address-management.php");
m_request->addParameter("peer_id",m_peer_id);
PlayerManager::setUserDetails(m_request, "get", Online::API::SERVER_PATH);
m_request->addParameter("peer_id", m_peer_id);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;
@ -63,10 +62,12 @@ void GetPeerAddress::asynchronousUpdate()
{
TransportAddress* addr = static_cast<TransportAddress*>(m_callback_object);
result->get("ip", &addr->ip);
if (addr->ip == NetworkManager::getInstance()->getPublicAddress().ip)
result->get("private_port", &addr->port);
else
result->get("port", &addr->port);
Log::debug("GetPeerAddress", "Address gotten successfully.");
}
else

3
src/network/protocols/hide_public_address.cpp
View File

@ -42,8 +42,7 @@ void HidePublicAddress::asynchronousUpdate()
if (m_state == NONE)
{
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "unset",
"address-management.php");
PlayerManager::setUserDetails(m_request, "unset", Online::API::SERVER_PATH);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;

3
src/network/protocols/quick_join_protocol.cpp
View File

@ -44,8 +44,7 @@ void QuickJoinProtocol::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "quick-join");
m_request->setServerURL("address-management.php");
PlayerManager::setUserDetails(m_request, "quick-join", Online::API::SERVER_PATH);
Online::RequestManager::get()->addRequest(m_request);
m_state = REQUEST_PENDING;

7
src/network/protocols/request_connection.cpp
View File

@ -72,9 +72,9 @@ void RequestConnection::asynchronousUpdate()
case NONE:
{
m_request = new ServerJoinRequest();
PlayerManager::setUserDetails(m_request, "request-connection",
"address-management.php");
m_request->addParameter("server_id",m_server_id);
PlayerManager::setUserDetails(m_request, "request-connection", Online::API::SERVER_PATH);
m_request->addParameter("server_id", m_server_id);
m_request->queue();
m_state = REQUEST_PENDING;
break;
@ -83,6 +83,7 @@ void RequestConnection::asynchronousUpdate()
{
if (!m_request->isDone())
return;
const XMLNode * result = m_request->getXMLData();
std::string rec_success;

15
src/network/protocols/server_lobby_room_protocol.cpp
View File

@ -183,16 +183,17 @@ void ServerLobbyRoomProtocol::checkIncomingConnectionRequests()
last_poll_time = StkTime::getRealTime();
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
Online::XMLRequest* request = new Online::XMLRequest();
PlayerManager::setUserDetails(request, "poll-connection-requests",
"address-management.php");
request->addParameter("address",addr.ip);
request->addParameter("port",addr.port);
PlayerManager::setUserDetails(request, "poll-connection-requests", Online::API::SERVER_PATH);
request->addParameter("address", addr.ip);
request->addParameter("port", addr.port);
request->executeNow();
assert(request->isDone());
const XMLNode * result = request->getXMLData();
std::string rec_success;
if(result->get("success", &rec_success))
{
if(rec_success == "yes")
@ -564,7 +565,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
* Byte 0 1 5 6 N+6 N+7 N+8
* -----------------------------------------------------------
* Size | 1 | 4 | 1 | N | 1 | 1 |
* Data | 4 | priv token | N | track name | 1 | track number (gp) |
* Data | 4 | priv token | N | track name | 1 | track number (gp) |
* -----------------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
@ -597,7 +598,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
* Byte 0 1 5 6 7 8 9
* ---------------------------------------------------------
* Size | 1 | 4 | 1 | 1 | 1 | 1 |
* Data | 4 | priv token | 1 | reversed | 1 | track number (gp) |
* Data | 4 | priv token | 1 | reversed | 1 | track number (gp) |
* ---------------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
@ -630,7 +631,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
* Byte 0 1 5 6 7 8 9
* -----------------------------------------------------
* Size | 1 | 4 | 1 | 1 | 1 | 1 |
* Data | 4 | priv token | 1 | laps | 1 | track number (gp) |
* Data | 4 | priv token | 1 | laps | 1 | track number (gp) |
* -----------------------------------------------------
*/
void ServerLobbyRoomProtocol::playerLapsVote(Event* event)

11
src/network/protocols/show_public_address.cpp
View File

@ -43,11 +43,12 @@ void ShowPublicAddress::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "set",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
m_request->addParameter("private_port",NetworkManager::getInstance()->getHost()->getPort());
PlayerManager::setUserDetails(m_request, "set", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
m_request->addParameter("private_port", NetworkManager::getInstance()->getHost()->getPort());
Log::info("ShowPublicAddress", "Showing addr %u and port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

13
src/network/protocols/start_server.cpp
View File

@ -42,12 +42,13 @@ void StartServer::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "start-server",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
m_request->addParameter("private_port",NetworkManager::getInstance()->getHost()->getPort());
m_request->addParameter("max_players",UserConfigParams::m_server_max_players);
PlayerManager::setUserDetails(m_request, "start", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
m_request->addParameter("private_port", NetworkManager::getInstance()->getHost()->getPort());
m_request->addParameter("max_players", UserConfigParams::m_server_max_players);
Log::info("ShowPublicAddress", "Showing addr %u and port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

9
src/network/protocols/stop_server.cpp
View File

@ -47,10 +47,11 @@ void StopServer::asynchronousUpdate()
{
TransportAddress addr = NetworkManager::getInstance()->getPublicAddress();
m_request = new Online::XMLRequest();
PlayerManager::setUserDetails(m_request, "stop-server",
"address-management.php");
m_request->addParameter("address",addr.ip);
m_request->addParameter("port",addr.port);
PlayerManager::setUserDetails(m_request, "stop", Online::API::SERVER_PATH);
m_request->addParameter("address", addr.ip);
m_request->addParameter("port", addr.port);
Log::info("StopServer", "address %u, port %d", addr.ip, addr.port);
Online::RequestManager::get()->addRequest(m_request);

91
src/online/http_request.cpp
View File

@ -26,12 +26,14 @@
#endif
#include <curl/curl.h>
#include <assert.h>
namespace Online
{
const std::string API::VERSION = "v2";
const std::string API::USER_PATH = "user/";
const std::string API::SERVER_PATH = "server/";
/** Creates a HTTP(S) request that will have a raw string as result. (Can
* of course be used if the result doesn't matter.)
* \param manage_memory whether or not the RequestManager should take care of
@ -60,7 +62,8 @@ namespace Online
// A http request should not even be created when internet is disabled
assert(UserConfigParams::m_internet_status ==
RequestManager::IPERM_ALLOWED);
assert(filename.size()>0);
assert(filename.size() > 0);
init();
m_filename = file_manager->getAddonsFile(filename);
} // HTTPRequest(filename ...)
@ -76,6 +79,7 @@ namespace Online
// A http request should not even be created when internet is disabled
assert(UserConfigParams::m_internet_status ==
RequestManager::IPERM_ALLOWED);
init();
m_filename = file_manager->getAddonsFile(filename);
} // HTTPRequest(filename ...)
@ -96,24 +100,30 @@ namespace Online
// ------------------------------------------------------------------------
/** A handy shortcut that appends the given path to the URL of the
* mutiplayer server.
* \param path The path to add to the server.
* \param path The path to add to the server.(see API::USER_*)
* \param action The action to perform. eg: connect, pool
*/
void HTTPRequest::setServerURL(const std::string& path)
void HTTPRequest::setApiURL(const std::string& path, const std::string &action)
{
setURL((std::string)UserConfigParams::m_server_multiplayer+path);
setURL(
(std::string)UserConfigParams::m_server_multiplayer +
API::VERSION + "/" + // eg: v1, v2, etc
path + // eg: user/, server/
action + "/" // eg: connect/, pool/, get-server-list/
);
} // setServerURL
// ------------------------------------------------------------------------
/** A handy shortcut that appends the given path to the URL of the addons
* server.
* \param path The path to add to the server.
* \param path The path to add to the server, without the trailing slash
*/
void HTTPRequest::setAddonsURL(const std::string& path)
{
setURL((std::string)UserConfigParams::m_server_addons
+ "/" + path);
setURL((std::string)UserConfigParams::m_server_addons + "/" + path);
} // set AddonsURL
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Checks the request if it has enough (correct) information to be
* executed (and thus allowed to add to the queue).
*/
@ -128,7 +138,7 @@ namespace Online
void HTTPRequest::prepareOperation()
{
m_curl_session = curl_easy_init();
if(!m_curl_session)
if (!m_curl_session)
{
Log::error("HTTPRequest::prepareOperation",
"LibCurl session not initialized.");
@ -145,9 +155,9 @@ namespace Online
curl_easy_setopt(m_curl_session, CURLOPT_LOW_SPEED_LIMIT, 10);
curl_easy_setopt(m_curl_session, CURLOPT_LOW_SPEED_TIME, 20);
//curl_easy_setopt(m_curl_session, CURLOPT_VERBOSE, 1L);
if(m_filename.size()==0)
if (m_filename.size() == 0)
{
//https
// https, load certificate info
struct curl_slist *chunk = NULL;
chunk = curl_slist_append(chunk, "Host: api.stkaddons.net");
curl_easy_setopt(m_curl_session, CURLOPT_HTTPHEADER, chunk);
@ -163,15 +173,15 @@ namespace Online
*/
void HTTPRequest::operation()
{
if(!m_curl_session)
if (!m_curl_session)
return;
FILE *fout = NULL;
if(m_filename.size()>0)
if (m_filename.size() > 0)
{
fout = fopen((m_filename+".part").c_str(), "wb");
if(!fout)
if (!fout)
{
Log::error("HTTPRequest",
"Can't open '%s' for writing, ignored.",
@ -190,23 +200,26 @@ namespace Online
}
// All parameters added have a '&' added
if(m_parameters.size()>0)
if (m_parameters.size() > 0)
{
m_parameters.erase(m_parameters.size()-1);
}
if(m_parameters.size()==0)
if (m_parameters.size() == 0)
{
Log::info("HTTPRequest", "Downloading %s", m_url.c_str());
else if (Log::getLogLevel()<=Log::LL_INFO)
}
else if (Log::getLogLevel() <= Log::LL_INFO)
{
// Avoid printing the password or token, just replace them with *s
std::string param = m_parameters;
// List of strings whose values should not be printed. "" is the
// end indicator.
static std::string dont_print[] = { "&password=", "&token=", "&current=",
"&new1=", "&new2=", ""};
"&new1=", "&new2=", "&password_confirm=", ""};
unsigned int j = 0;
while (dont_print[j].size()>0)
while (dont_print[j].size() > 0)
{
// Get the string that should be replaced.
std::size_t pos = param.find(dont_print[j]);
@ -221,11 +234,11 @@ namespace Online
} // if string found
j++;
} // while dont_print[j].size()>0
Log::info("HTTPRequest", "Sending %s to %s",
param.c_str(), m_url.c_str());
}
curl_easy_setopt(m_curl_session, CURLOPT_POSTFIELDS,
m_parameters.c_str());
Log::info("HTTPRequest", "Sending %s to %s", param.c_str(), m_url.c_str());
} // end log http request
curl_easy_setopt(m_curl_session, CURLOPT_POSTFIELDS, m_parameters.c_str());
std::string uagent( std::string("SuperTuxKart/") + STK_VERSION );
#ifdef WIN32
uagent += (std::string)" (Windows)";
@ -243,17 +256,18 @@ namespace Online
m_curl_code = curl_easy_perform(m_curl_session);
Request::operation();
if(fout)
if (fout)
{
fclose(fout);
if(m_curl_code==CURLE_OK)
if (m_curl_code == CURLE_OK)
{
if(UserConfigParams::logAddons())
Log::info("HTTPRequest", "Download successful.");
// The behaviour of rename is unspecified if the target
// file should already exist - so remove it.
bool ok = file_manager->removeFile(m_filename);
if(!ok)
if (!ok)
{
Log::error("addons",
"Could not removed existing addons.xml file.");
@ -261,8 +275,9 @@ namespace Online
}
int ret = rename((m_filename+".part").c_str(),
m_filename.c_str() );
// In case of an error, set the status to indicate this
if(ret!=0)
if (ret != 0)
{
Log::error("addons",
"Could not rename downloaded addons.xml file!");
@ -279,10 +294,11 @@ namespace Online
*/
void HTTPRequest::afterOperation()
{
if(m_curl_code == CURLE_OK)
if (m_curl_code == CURLE_OK)
setProgress(1.0f);
else
setProgress(-1.0f);
Request::afterOperation();
curl_easy_cleanup(m_curl_session);
} // afterOperation
@ -322,7 +338,7 @@ namespace Online
// Check if we are asked to abort the download. If so, signal this
// back to libcurl by returning a non-zero status.
if( (request_manager->getAbort() || request->isCancelled()) &&
if ((request_manager->getAbort() || request->isCancelled()) &&
request->isAbortable() )
{
// Indicates to abort the current download, which means that this
@ -331,23 +347,24 @@ namespace Online
}
float f;
if(download_now < download_total)
if (download_now < download_total)
{
f = (float)download_now / (float)download_total;
// In case of floating point rouding errors make sure that
// 1.0 is only reached when downloadFileInternal is finished
if (f>=1.0f) f=0.99f;
if (f >= 1.0f)
f = 0.99f;
}
else
{
// Don't set progress to 1.0f; this is done in afterOperation()
// after checking curls return code!
f= download_total==0 ? 0 : 0.99f;
f = (download_total == 0) ? 0 : 0.99f;
}
request->setProgress(f);
return 0;
} // progressDownload
} // namespace Online

66
src/online/http_request.hpp
View File

@ -34,6 +34,14 @@
namespace Online
{
class API
{
public:
static const std::string VERSION;
static const std::string USER_PATH;
static const std::string SERVER_PATH;
};
/** A http request.
*/
class HTTPRequest : public Request
@ -78,22 +86,20 @@ namespace Online
void init();
public :
HTTPRequest(bool manage_memory = false,
int priority = 1);
HTTPRequest(const std::string &filename,
bool manage_memory = false,
int priority = 1);
HTTPRequest(const char * const filename,
bool manage_memory = false,
int priority = 1);
virtual ~HTTPRequest() {};
HTTPRequest(bool manage_memory = false, int priority = 1);
HTTPRequest(const std::string &filename, bool manage_memory = false,
int priority = 1);
HTTPRequest(const char * const filename, bool manage_memory = false,
int priority = 1);
virtual ~HTTPRequest() {}
virtual bool isAllowedToAdd() const OVERRIDE;
void setServerURL(const std::string& url);
void setApiURL(const std::string& url, const std::string &action);
void setAddonsURL(const std::string& path);
// ------------------------------------------------------------------------
/** Returns true if there was an error downloading the file.
*/
bool hadDownloadError() const { return m_curl_code!=CURLE_OK; }
/** Returns true if there was an error downloading the file. */
bool hadDownloadError() const { return m_curl_code != CURLE_OK; }
// ------------------------------------------------------------------------
/** Returns the curl error message if an error has occurred.
* \pre m_curl_code!=CURLE_OK
@ -116,47 +122,50 @@ namespace Online
} // getData
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (std::string).
*/
/** Sets a parameter to 'value' (std::string). */
void addParameter(const std::string & name, const std::string &value)
{
// Call the template, so that the strings are escaped properly
addParameter(name, value.c_str());
}; // addParameter
} // addParameter
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (stringw).
*/
void addParameter(const std::string & name,
/** Sets a parameter to 'value' (stringw). */
void addParameter(const std::string &name,
const irr::core::stringw &value)
{
core::stringc s = core::stringc(value.c_str());
// Call the template to escape strings properly
addParameter(name, s.c_str());
} // addParameter
// --------------------------------------------------------------------
/** Sets a parameter to 'value' (arbitrary types).
*/
/** Sets a parameter to 'value' (arbitrary types). */
template <typename T>
void addParameter(const std::string & name, const T& value)
void addParameter(const std::string &name, const T& value)
{
assert(isPreparing());
std::string s = StringUtils::toString(value);
char *s1 = curl_easy_escape(m_curl_session, name.c_str(),
name.size() );
char *s1 = curl_easy_escape(m_curl_session, name.c_str(), name.size());
char *s2 = curl_easy_escape(m_curl_session, s.c_str(), s.size());
m_parameters.append(std::string(s1)+"="+s2+"&");
m_parameters.append(std::string(s1) + "=" + s2 + "&");
curl_free(s1);
curl_free(s2);
} // addParameter
// --------------------------------------------------------------------
/** Returns the current progress. */
float getProgress() const { return m_progress.getAtomic(); }
// --------------------------------------------------------------------
/** Sets the current progress. */
void setProgress(float f) { m_progress.setAtomic(f); }
void setProgress(float f) { m_progress.setAtomic(f); }
// --------------------------------------------------------------------
const std::string & getURL() const { assert(isBusy()); return m_url;}
// --------------------------------------------------------------------
/** Sets the URL for this request. */
void setURL(const std::string & url)
@ -166,8 +175,5 @@ namespace Online
} // setURL
}; // class HTTPRequest
} //namespace Online
#endif
#endif // HEADER_HTTP_REQUEST_HPP

298
src/online/online_player_profile.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/online_player_profile.hpp"
#include "achievements/achievements_manager.hpp"
@ -49,23 +48,25 @@ namespace Online
/** Adds the login credential to a http request. It sets the name of
* the script to invokce, token, and user id.
* \param request The http request.
* \param action If not empty, the action to be set.
* \param action the action performed
*/
void OnlinePlayerProfile::setUserDetails(HTTPRequest *request,
const std::string &action,
const std::string &php_script) const
const std::string &url_path) const
{
if (php_script.size()>0)
request->setServerURL(php_script);
else
request->setServerURL("client-user.php");
if (url_path.size())
{
request->setApiURL(url_path, action);
}
else // default path
{
request->setApiURL(API::USER_PATH, action);
}
if (m_profile)
request->addParameter("userid", m_profile->getID());
if(m_online_state == OS_SIGNED_IN)
if (m_online_state == OS_SIGNED_IN)
request->addParameter("token", m_token);
if (action.size() > 0)
request->addParameter("action", action);
} // setUserDetails
// ========================================================================
@ -86,16 +87,17 @@ namespace Online
m_profile = NULL;
} // OnlinePlayerProfile
// ------------------------------------------------------------------------
/** Request a login using the saved credentials of the user.
*/
/** Request a login using the saved credentials of the user. */
void OnlinePlayerProfile::requestSavedSession()
{
SignInRequest * request = NULL;
SignInRequest *request = NULL;
if (m_online_state == OS_SIGNED_OUT && hasSavedSession())
{
request = new SignInRequest(true);
setUserDetails(request, "saved-session");
// The userid must be taken from the saved data,
// setUserDetails takes it from current data.
request->addParameter("userid", getSavedUserId());
@ -117,18 +119,19 @@ namespace Online
// If the player changes the online account, there can be a
// logout stil happening.
assert(m_online_state == OS_SIGNED_OUT ||
m_online_state == OS_SIGNING_OUT );
m_online_state == OS_SIGNING_OUT);
SignInRequest * request = new SignInRequest(false);
// We can't use setUserDetail here, since there is no token yet
request->setServerURL("client-user.php");
request->addParameter("action","connect");
request->addParameter("username",username);
request->addParameter("password",password);
request->setApiURL(API::USER_PATH, "connect");
request->addParameter("username", username);
request->addParameter("password", password);
request->addParameter("save-session",
rememberPassword() ? "true"
: "false");
request->queue();
m_online_state = OS_SIGNING_IN;
return request;
} // requestSignIn
@ -143,13 +146,13 @@ namespace Online
// If the login is successful, reset any saved session of other
// local players using the same online account (which are now invalid)
if(isSuccess())
if (isSuccess())
{
PlayerProfile *current = PlayerManager::getCurrentPlayer();
for(unsigned int i=0; i<PlayerManager::get()->getNumPlayers(); i++)
for (unsigned int i = 0; i < PlayerManager::get()->getNumPlayers(); i++)
{
PlayerProfile *player = PlayerManager::get()->getPlayer(i);
if(player!=current &&
if(player != current &&
player->hasSavedSession() &&
player->getLastOnlineName() == current->getLastOnlineName())
{
@ -157,7 +160,8 @@ namespace Online
}
}
}
if(login)
if (login)
{
if(isSuccess())
login->loginSuccessful();
@ -178,12 +182,14 @@ namespace Online
{
if (success)
{
int token_fetched = input->get("token", &m_token);
core::stringw username("");
int username_fetched = input->get("username", &username);
uint32_t userid(0);
int token_fetched = input->get("token", &m_token);
int username_fetched = input->get("username", &username);
int userid_fetched = input->get("userid", &userid);
setLastOnlineName(username);
m_profile = new OnlineProfile(userid, username, true);
assert(token_fetched && username_fetched && userid_fetched);
m_online_state = OS_SIGNED_IN;
@ -191,8 +197,10 @@ namespace Online
{
saveSession(getOnlineId(), getToken());
}
ProfileManager::get()->addPersistent(m_profile);
std::string achieved_string("");
// Even if no achievements were sent, we have to call sync
// in order to upload local achievements to the server
input->get("achieved", &achieved_string);
@ -260,6 +268,7 @@ namespace Online
{
GUIEngine::Screen *screen = GUIEngine::getCurrentScreen();
BaseUserScreen *user_screen = dynamic_cast<BaseUserScreen*>(screen);
// We can't do much of error handling here, no screen waits for
// a logout to finish, so we can only log the message to screen,
// and otherwise mark the player logged out internally.
@ -269,20 +278,21 @@ namespace Online
"There were some connection issues while signing out. "
"Report a bug if this caused issues.");
Log::warn("OnlinePlayerProfile::signOut", core::stringc(info.c_str()).c_str());
if(user_screen)
if (user_screen)
user_screen->logoutError(info);
}
else
{
if(user_screen)
if (user_screen)
user_screen->logoutSuccessful();
}
ProfileManager::get()->clearPersistent();
m_profile = NULL;
m_online_state = OS_SIGNED_OUT;
// Discard token if session should not be saved.
if(!rememberPassword())
if (!rememberPassword())
clearSession();
} // signOut
@ -293,7 +303,8 @@ namespace Online
void OnlinePlayerProfile::requestPoll() const
{
assert(m_online_state == OS_SIGNED_IN);
OnlinePlayerProfile::PollRequest * request = new OnlinePlayerProfile::PollRequest();
OnlinePlayerProfile::PollRequest *request = new OnlinePlayerProfile::PollRequest();
setUserDetails(request, "poll");
request->queue();
} // requestPoll()
@ -304,127 +315,137 @@ namespace Online
*/
void OnlinePlayerProfile::PollRequest::callback()
{
if(isSuccess())
// connection error
if (!isSuccess())
{
if (!PlayerManager::getCurrentPlayer()->isLoggedIn())
return;
if (PlayerManager::getCurrentPlayer()->getProfile()->hasFetchedFriends())
Log::error("Online Player Profile", "Poll request failed");
return;
}
if (!PlayerManager::getCurrentPlayer()->isLoggedIn())
return;
if (PlayerManager::getCurrentPlayer()->getProfile()->hasFetchedFriends())
{
std::string online_friends_string("");
if (getXMLData()->get("online", &online_friends_string) == 1)
{
std::string online_friends_string("");
if(getXMLData()->get("online", &online_friends_string) == 1)
std::vector<uint32_t> online_friends =
StringUtils::splitToUInt(online_friends_string, ' ');
// flag that indicates if a current online friend went offline
bool went_offline = false;
// iterate over all friends and find out if they come online or not
// filling the notification messages
std::vector<uint32_t> friends =
PlayerManager::getCurrentPlayer()->getProfile()->getFriends();
std::vector<core::stringw> to_notify;
for (unsigned int i = 0; i < friends.size(); ++i)
{
std::vector<uint32_t> online_friends =
StringUtils::splitToUInt(online_friends_string, ' ');
bool went_offline = false;
std::vector<uint32_t> friends =
PlayerManager::getCurrentPlayer()->getProfile()->getFriends();
std::vector<core::stringw> to_notify;
for(unsigned int i = 0; i < friends.size(); ++i)
{
bool now_online = false;
std::vector<uint32_t>::iterator iter =
std::find(online_friends.begin(),
online_friends.end(), friends[i]);
if (iter != online_friends.end())
{
now_online = true;
online_friends.erase(iter);
}
OnlineProfile * profile =
ProfileManager::get()->getProfileByID(friends[i]);
OnlineProfile::RelationInfo * relation_info =
profile->getRelationInfo();
if( relation_info->isOnline() )
{
if (!now_online)
{
relation_info->setOnline(false);
went_offline = true;
}
}
else
{
if (now_online)
{
//User came online
relation_info->setOnline(true);
// Do this because a user might have accepted
// a pending friend request.
profile->setFriend();
to_notify.push_back(profile->getUserName());
}
}
bool now_online = false;
std::vector<uint32_t>::iterator found_friend =
std::find(online_friends.begin(),
online_friends.end(), friends[i]);
if (found_friend != online_friends.end())
{
now_online = true;
online_friends.erase(found_friend);
}
}
OnlineProfile * profile =
ProfileManager::get()->getProfileByID(friends[i]);
OnlineProfile::RelationInfo * relation_info =
profile->getRelationInfo();
if(to_notify.size() > 0)
{
core::stringw message("");
if(to_notify.size() == 1)
{
message = _("%s is now online.", to_notify[0]);
}
else if(to_notify.size() == 2)
{
message = _("%s and %s are now online.",
to_notify[0], to_notify[1] );
}
else if(to_notify.size() == 3)
{
message = _("%s, %s and %s are now online.",
to_notify[0], to_notify[1], to_notify[2]);
}
else if(to_notify.size() > 3)
{
message = _("%d friends are now online.",
to_notify.size());
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
}
else if(went_offline)
{
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
if (relation_info->isOnline())
{
if (!now_online) // the friend went offline
{
relation_info->setOnline(false);
went_offline = true;
}
}
else
{
if (now_online) // friend came online
{
relation_info->setOnline(true);
// Do this because a user might have accepted
// a pending friend request.
profile->setFriend();
to_notify.push_back(profile->getUserName());
}
}
}
if (to_notify.size() > 0)
{
core::stringw message("");
if(to_notify.size() == 1)
{
message = _("%s is now online.", to_notify[0]);
}
else if(to_notify.size() == 2)
{
message = _("%s and %s are now online.",
to_notify[0], to_notify[1] );
}
else if(to_notify.size() == 3)
{
message = _("%s, %s and %s are now online.",
to_notify[0], to_notify[1], to_notify[2]);
}
else if(to_notify.size() > 3)
{
message = _("%d friends are now online.",
to_notify.size());
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
}
else if (went_offline)
{
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
}
}
else
{
PlayerManager::getCurrentPlayer()->getProfile()->fetchFriends();
}
int friend_request_count = 0;
for (unsigned int i = 0; i < getXMLData()->getNumNodes(); i++)
{
const XMLNode * node = getXMLData()->getNode(i);
if (node->getName() == "new_friend_request")
{
OnlineProfile::RelationInfo * ri =
new OnlineProfile::RelationInfo("New", false, true, true);
OnlineProfile * p = new OnlineProfile(node);
p->setRelationInfo(ri);
ProfileManager::get()->addPersistent(p);
friend_request_count++;
}
}
if (friend_request_count > 0)
{
core::stringw message("");
if (friend_request_count > 1)
{
message = _("You have %d new friend requests!",
friend_request_count);
}
else
{
PlayerManager::getCurrentPlayer()->getProfile()->fetchFriends();
message = _("You have a new friend request!");
}
int friend_request_count = 0;
for(unsigned int i = 0; i < getXMLData()->getNumNodes(); i++)
{
const XMLNode * node = getXMLData()->getNode(i);
if(node->getName() == "new_friend_request")
{
OnlineProfile::RelationInfo * ri =
new OnlineProfile::RelationInfo("New", false, true, true);
OnlineProfile * p = new OnlineProfile(node);
p->setRelationInfo(ri);
ProfileManager::get()->addPersistent(p);
friend_request_count++;
}
}
if(friend_request_count > 0)
{
core::stringw message("");
if(friend_request_count > 1)
{
message = _("You have %d new friend requests!",
friend_request_count);
}
else
{
message = _("You have a new friend request!");
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
MessageQueue::add(MessageQueue::MT_FRIEND, message);
OnlineProfileFriends::getInstance()->refreshFriendsList();
}
// FIXME show connection error??
// Perhaps show something after 2 misses.
} // PollRequest::callback
// ------------------------------------------------------------------------
@ -432,11 +453,12 @@ namespace Online
*/
uint32_t OnlinePlayerProfile::getOnlineId() const
{
if((m_online_state == OS_SIGNED_IN ))
if (m_online_state == OS_SIGNED_IN)
{
assert(m_profile != NULL);
return m_profile->getID();
}
return 0;
} // getOnlineId

131
src/online/online_player_profile.hpp
View File

@ -37,7 +37,6 @@ class PlayerManager;
namespace Online
{
class OnlineProfile;
// ============================================================================
@ -48,75 +47,73 @@ namespace Online
*/
class OnlinePlayerProfile : public PlayerProfile
{
public:
// ----------------------------------------------------------------
class SignInRequest : public XMLRequest
{
virtual void callback ();
public:
// ----------------------------------------------------------------
class SignInRequest : public XMLRequest
{
virtual void callback ();
public:
SignInRequest(bool manage_memory = false)
: XMLRequest(manage_memory, /*priority*/10) {}
}; // SignInRequest
// ----------------------------------------------------------------
class PollRequest : public XMLRequest {
virtual void callback ();
public:
PollRequest() : XMLRequest(true) {}
}; // PollRequest
private:
std::string m_token;
OnlineProfile *m_profile;
/** The state of the player (logged in, logging in, ...) */
PlayerProfile::OnlineState m_online_state;
virtual void signIn(bool success, const XMLNode * input);
virtual void signOut(bool success, const XMLNode * input,
const irr::core::stringw &info);
virtual uint32_t getOnlineId() const;
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &php_script = "") const;
virtual void requestPoll() const;
// ----------------------------------------------------------------
/** Returns if this user is logged in. */
virtual bool isLoggedIn() const
{
return m_online_state == PlayerProfile::OS_SIGNED_IN;
} // isLoggedIn
// ----------------------------------------------------------------
/** The online state of the player (i.e. logged out, logging in,
* logged in, ...). */
PlayerProfile::OnlineState getOnlineState() const
{
return m_online_state;
} // getOnlineState
// ----------------------------------------------------------------
/** Returns a pointer to the profile associated with the current
* user. */
OnlineProfile* getProfile() const { return m_profile; }
// ----------------------------------------------------------------
/** Returns the session token of the signed in user. */
const std::string& getToken() const { return m_token; }
virtual void requestSavedSession();
virtual void requestSignOut();
virtual SignInRequest *requestSignIn(const irr::core::stringw &username,
const irr::core::stringw &password);
SignInRequest(bool manage_memory = false)
: XMLRequest(manage_memory, /*priority*/10) {}
}; // SignInRequest
// ----------------------------------------------------------------
class PollRequest : public XMLRequest
{
virtual void callback ();
public:
OnlinePlayerProfile(const XMLNode *player);
OnlinePlayerProfile(const core::stringw &name, bool is_guest = false);
virtual ~OnlinePlayerProfile() {};
// ----------------------------------------------------------------
PollRequest() : XMLRequest(true) {}
}; // PollRequest
}; // class OnlinePlayerProfile
private:
std::string m_token;
OnlineProfile *m_profile;
/** The state of the player (logged in, logging in, ...) */
PlayerProfile::OnlineState m_online_state;
virtual void signIn(bool success, const XMLNode * input);
virtual void signOut(bool success, const XMLNode * input,
const irr::core::stringw &info);
virtual uint32_t getOnlineId() const;
virtual void setUserDetails(Online::HTTPRequest *request,
const std::string &action,
const std::string &url_path = "") const;
virtual void requestPoll() const;
// ----------------------------------------------------------------
/** Returns if this user is logged in. */
virtual bool isLoggedIn() const
{
return m_online_state == PlayerProfile::OS_SIGNED_IN;
} // isLoggedIn
// ----------------------------------------------------------------
/** The online state of the player (i.e. logged out, logging in,
* logged in, ...). */
PlayerProfile::OnlineState getOnlineState() const
{
return m_online_state;
} // getOnlineState
// ----------------------------------------------------------------
/** Returns a pointer to the profile associated with the current user. */
OnlineProfile* getProfile() const { return m_profile; }
// ----------------------------------------------------------------
/** Returns the session token of the signed in user. */
const std::string& getToken() const { return m_token; }
virtual void requestSavedSession();
virtual void requestSignOut();
virtual SignInRequest *requestSignIn(const irr::core::stringw &username,
const irr::core::stringw &password);
public:
OnlinePlayerProfile(const XMLNode *player);
OnlinePlayerProfile(const core::stringw &name, bool is_guest = false);
virtual ~OnlinePlayerProfile() {}
// ----------------------------------------------------------------
}; // class OnlinePlayerProfile
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_CURRENT_ONLINE_USER_HPP

58
src/online/online_profile.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/online_profile.hpp"
#include "config/player_manager.hpp"
@ -39,10 +38,10 @@ OnlineProfile::RelationInfo::RelationInfo(const irr::core::stringw & date,
bool is_online, bool is_pending,
bool is_asker)
{
m_date = date;
m_is_online = is_online;
m_is_pending = is_pending;
m_is_asker = is_asker;
m_date = date;
m_is_online = is_online;
m_is_pending = is_pending;
m_is_asker = is_asker;
} // RelationInfo::RelationInfo
// ----------------------------------------------------------------------------
@ -91,12 +90,11 @@ OnlineProfile::OnlineProfile(const XMLNode * xml, ConstructorType type)
if (type == C_RELATION_INFO)
{
irr::core::stringw date("");
bool is_pending = false, is_asker = false, is_online = false;
xml->get("date", &date);
std::string is_pending_string("");
bool is_pending = false;
xml->get("is_pending", &is_pending);
bool is_asker = false;
bool is_online = false;
if (is_pending)
{
xml->get("is_asker", &is_asker);
@ -113,7 +111,7 @@ OnlineProfile::OnlineProfile(const XMLNode * xml, ConstructorType type)
xml->get("id", &m_id );
xml->get("user_name", &m_username);
m_is_current_user = (m_id == PlayerManager::getCurrentOnlineId());
m_is_current_user = (m_id == PlayerManager::getCurrentOnlineId());
m_state = S_READY;
} // OnlineProfile(XMLNode)
@ -133,6 +131,7 @@ void OnlineProfile::fetchAchievements()
assert(PlayerManager::isCurrentLoggedIn());
if (m_has_fetched_achievements || m_is_current_user)
return;
m_state = S_FETCHING;
// ------------------------------------------------------------------------
@ -187,6 +186,7 @@ void OnlineProfile::fetchFriends()
assert(PlayerManager::isCurrentLoggedIn());
if (m_has_fetched_friends)
return;
m_state = S_FETCHING;
// ------------------------------------------------------------------------
@ -258,9 +258,11 @@ void OnlineProfile::removeFriend(const uint32_t id)
break;
}
else
{
++iter;
}
} // removeFriend
}
} // for friend in friends
} // removeFriend
// ----------------------------------------------------------------------------
/** Adds a friend to the friend list.
@ -269,9 +271,14 @@ void OnlineProfile::removeFriend(const uint32_t id)
void OnlineProfile::addFriend(const uint32_t id)
{
assert(m_has_fetched_friends);
// find if friend id is is already in the user list
for (unsigned int i = 0; i < m_friends.size(); i++)
if (m_friends[i] == id)
return;
{
if (m_friends[i] == id)
return;
}
m_friends.push_back(id);
} // addFriend
@ -310,18 +317,25 @@ const OnlineProfile::IDList& OnlineProfile::getAchievements()
void OnlineProfile::merge(OnlineProfile *profile)
{
assert(profile != NULL);
if (!this->m_has_fetched_friends && profile->m_has_fetched_friends)
this->m_friends = profile->m_friends;
if (!this->m_has_fetched_achievements && profile->m_has_fetched_achievements)
this->m_achievements = profile->m_achievements;
if (this->m_relation_info == NULL && profile->m_relation_info != NULL)
// profile has fetched friends, use that instead
if (!m_has_fetched_friends && profile->m_has_fetched_friends)
m_friends = profile->m_friends;
// profile has fetched achievements, use that instead
if (!m_has_fetched_achievements && profile->m_has_fetched_achievements)
m_achievements = profile->m_achievements;
// current relation is not set, use the profile one
if (m_relation_info == NULL && profile->m_relation_info != NULL)
{
this->m_relation_info = profile->m_relation_info;
m_relation_info = profile->m_relation_info;
// We don't want the destructor of the profile instance to destroy
// the relation info
profile->m_relation_info = NULL;
}
delete profile;
} // merge
delete profile;
} // merge
} // namespace Online

38
src/online/online_profile.hpp
View File

@ -24,9 +24,7 @@
#include "utils/types.hpp"
#include "utils/ptr_vector.hpp"
#include <irrString.h>
#include <string>
namespace Online
@ -54,16 +52,21 @@ public:
bool m_is_pending;
bool m_is_asker;
irr::core::stringw m_date;
public:
RelationInfo(const irr::core::stringw & date, bool is_online,
bool is_pending, bool is_asker = false);
void setOnline(bool online);
// --------------------------------------------------------------------
bool isPending() const { return m_is_pending; }
// --------------------------------------------------------------------
bool isAsker() const { return m_is_asker; }
// --------------------------------------------------------------------
const irr::core::stringw & getDate() const { return m_date; }
// --------------------------------------------------------------------
bool isOnline() const { return m_is_online; }
}; // class RelationInfo
@ -104,12 +107,11 @@ private:
void storeAchievements(const XMLNode * input);
public:
OnlineProfile(const uint32_t & userid,
const irr::core::stringw & username,
bool is_current_user = false );
OnlineProfile(const XMLNode * xml,
ConstructorType type = C_DEFAULT);
~OnlineProfile();
OnlineProfile(const uint32_t & userid,
const irr::core::stringw & username,
bool is_current_user = false );
OnlineProfile(const XMLNode * xml, ConstructorType type = C_DEFAULT);
~OnlineProfile();
void fetchFriends();
const IDList& getFriends();
void fetchAchievements();
@ -118,49 +120,55 @@ public:
void deleteRelationalInfo();
const IDList& getAchievements();
void merge(OnlineProfile * profile);
// ------------------------------------------------------------------------
/** Returns true if the achievements for this profile have been fetched. */
bool hasFetchedAchievements() const { return m_has_fetched_achievements; }
// ------------------------------------------------------------------------
/** Returns true if the friend list for this profile has been fetched. */
bool hasFetchedFriends() const { return m_has_fetched_friends; }
// ------------------------------------------------------------------------
/** True if the profile is not fetching data atm. */
bool isReady() const { return m_state == S_READY; }
// ------------------------------------------------------------------------
/** Returns true if this item is the current user. */
bool isCurrentUser() const { return m_is_current_user; }
// ------------------------------------------------------------------------
bool isFriend() const { return m_is_friend; }
// ------------------------------------------------------------------------
void setFriend() { m_is_friend = true; }
// ------------------------------------------------------------------------
RelationInfo* getRelationInfo() { return m_relation_info; }
// ------------------------------------------------------------------------
void setRelationInfo(RelationInfo * r)
{
delete m_relation_info; m_relation_info = r;
} // setRelationInfo
// ------------------------------------------------------------------------
/** Sets the cache bit of this profile. Used by the cache eviction
* algorithm. */
void setCacheBit(bool cache_bit) { m_cache_bit = cache_bit; }
// ------------------------------------------------------------------------
/** Returns the cache bit for this profile. Used by the cache eviction
* algorithm. */
bool getCacheBit() const { return m_cache_bit; }
// ------------------------------------------------------------------------
/** Returns the online id of this profile. */
uint32_t getID() const { return m_id; }
// ------------------------------------------------------------------------
/** Returns the user name of this profile. */
const irr::core::stringw& getUserName() const { return m_username; }
// ------------------------------------------------------------------------
}; // class OnlineProfile
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_ONLINE_PROFILE_HPP

24
src/online/profile_manager.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/profile_manager.hpp"
#include "online/online_profile.hpp"
@ -50,7 +49,8 @@ ProfileManager::~ProfileManager()
{
clearPersistent();
ProfilesMap::iterator it;
for (it = m_profiles_cache.begin(); it != m_profiles_cache.end(); ++it) {
for (it = m_profiles_cache.begin(); it != m_profiles_cache.end(); ++it)
{
delete it->second;
}
} // ~ProfileManager
@ -72,8 +72,8 @@ int ProfileManager::guaranteeCacheSize(unsigned int min_num)
min_num = 100;
m_max_cache_size = min_num;
}
return m_max_cache_size;
return m_max_cache_size;
} // guaranteeCacheSize
// ------------------------------------------------------------------------
@ -88,7 +88,8 @@ OnlineProfile* ProfileManager::getProfileByID(const uint32_t id)
return m_profiles_persistent[id];
if (isInCache(id))
return m_profiles_cache[id];
//FIXME not able to get! Now this should actually fetch the info from the
// FIXME not able to get! Now this should actually fetch the info from the
// server, but I haven't come up with a good asynchronous idea yet.
return NULL;
} // getProfileByID
@ -135,12 +136,14 @@ void ProfileManager::addDirectToCache(OnlineProfile* profile)
break;
}
else
{
++iter;
}
}
} // for profile in cache
}
m_profiles_cache[profile->getID()] = profile;
assert(m_profiles_cache.size() <= m_max_cache_size);
} // addDirectToCache
// ------------------------------------------------------------------------
@ -155,6 +158,7 @@ bool ProfileManager::isInCache(const uint32_t id)
updateCacheBits(i->second);
return true;
}
return false;
} // isInCache
@ -180,6 +184,7 @@ void ProfileManager::updateCacheBits(OnlineProfile * profile)
if (!iter->second->getCacheBit())
return;
}
// All cache bits are set! Set them all to zero except the one
// currently being visited
for (iter = m_profiles_cache.begin();
@ -189,7 +194,6 @@ void ProfileManager::updateCacheBits(OnlineProfile * profile)
}
profile->setCacheBit(true);
}
} // updateCacheBits
// ------------------------------------------------------------------------
@ -232,11 +236,14 @@ void ProfileManager::deleteFromPersistent(const uint32_t id)
m_profiles_persistent.erase(id);
}
else
{
Log::warn("ProfileManager",
"Tried to remove profile with id %d from persistent while "
"not present", id);
}
} // deleteFromPersistent
// ------------------------------------------------------------------------
/** Deletes all persistent profiles.
*/
@ -265,10 +272,11 @@ void ProfileManager::moveToCache(const uint32_t id)
addToCache(profile);
}
else
{
Log::warn("ProfileManager",
"Tried to move profile with id %d from persistent to "
"cache while not present", id);
}
} // moveToCache
} // namespace Online

10
src/online/profile_manager.hpp
View File

@ -29,7 +29,6 @@
namespace Online
{
class OnlineProfile;
/** Class that manages all online profiles. Profiles are used for storing
@ -81,6 +80,7 @@ public:
assert(!m_profile_manager);
m_profile_manager = new ProfileManager();
} // create
// ----------------------------------------------------------------
/** Returns the singleton.
* \pre create has been called to create the singleton.
@ -109,6 +109,7 @@ public:
bool isInCache(const uint32_t id);
bool inPersistent(const uint32_t id);
OnlineProfile* getProfileByID(const uint32_t id);
// ----------------------------------------------------------------
/** Marks a given profile to be the currently visited one. This
* is used to mark the profiles that ave its data display (e.g.
@ -117,15 +118,12 @@ public:
{
m_currently_visiting = getProfileByID(id);
} // setVisiting
// ----------------------------------------------------------------
/** \return the instance of the profile that's currently being
* visited */
OnlineProfile* getVisitingProfile() { return m_currently_visiting; }
}; // class CurrentUser
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_ONLINE_PROFILE_MANAGER_HPP

4
src/online/request.cpp
View File

@ -25,10 +25,8 @@
#include <assert.h>
namespace Online
{
// ========================================================================
/**
* Creates a request that can be handled by the RequestManager
@ -67,6 +65,7 @@ namespace Online
setExecuted();
afterOperation();
} // execute
// ------------------------------------------------------------------------
/** Executes the request now, i.e. in the main thread and without involving
* the manager thread.. This calles prepareOperation, operation, and
@ -81,5 +80,4 @@ namespace Online
setDone();
} // executeNow
} // namespace Online

36
src/online/request.hpp
View File

@ -35,7 +35,6 @@
namespace Online
{
/** Stores a request for the HTTP Manager. They will be sorted by
* prioritiy. Requests have four different states they can be in, and
* this state determines which thread can access it. This allows
@ -119,9 +118,11 @@ namespace Online
/** The actual operation to be executed. Empty as default, which
* allows to create a 'quit' request without any additional code. */
virtual void operation() {}
// --------------------------------------------------------------------
/** Virtual function to be called before an operation. */
virtual void prepareOperation() {}
// --------------------------------------------------------------------
/** Virtual function to be called after an operation. */
virtual void afterOperation() {}
@ -132,71 +133,87 @@ namespace Online
RT_QUIT = 1
};
Request(bool manage_memory, int priority, int type);
Request(bool manage_memory, int priority, int type);
virtual ~Request() {}
void execute();
void executeNow();
void queue();
// --------------------------------------------------------------------
/** Executed when a request has finished. */
virtual void callback() {}
// --------------------------------------------------------------------
/** Returns the type of the request. */
int getType() const { return m_type; }
// --------------------------------------------------------------------
/** Returns if the memory for this object should be managed by
* by network_http (i.e. freed once the request is handled). */
bool manageMemory() const { return m_manage_memory; }
// --------------------------------------------------------------------
/** Sets the memory management flag of this request. This function
* must only be called by the main thread, since it is only tested by
* the main thread. */
void setManageMemory(bool m) { m_manage_memory = m; }
// --------------------------------------------------------------------
/** Returns the priority of this request. */
int getPriority() const { return m_priority; }
// --------------------------------------------------------------------
/** Signals that this request should be canceled. */
void cancel() { m_cancel.setAtomic(true); }
// --------------------------------------------------------------------
/** Returns if this request is to be canceled. */
bool isCancelled() const { return m_cancel.getAtomic(); }
// --------------------------------------------------------------------
/** Returns if this request can be aborted. */
bool isAbortable() const { return m_is_abortable.getAtomic(); }
// --------------------------------------------------------------------
/** Sets if this request is abortable or not. */
void setAbortable(bool b) { m_is_abortable.setAtomic(b); }
// --------------------------------------------------------------------
/** Sets the request state to busy. */
void setBusy()
{
assert(m_state.getAtomic()==S_PREPARING);
assert(m_state.getAtomic() == S_PREPARING);
m_state.setAtomic(S_BUSY);
} // setBusy
// --------------------------------------------------------------------
/** Sets the request to be completed. */
void setExecuted()
{
assert(m_state.getAtomic()==S_BUSY);
assert(m_state.getAtomic() == S_BUSY);
m_state.setAtomic(S_EXECUTED);
} // setExecuted
// --------------------------------------------------------------------
/** Should only be called by the manager */
void setDone()
{
assert(m_state.getAtomic()==S_EXECUTED);
assert(m_state.getAtomic() == S_EXECUTED);
m_state.setAtomic(S_DONE);
} // setDone
// --------------------------------------------------------------------
/** Returns if this request is done. */
bool isDone() const { return m_state.getAtomic() == S_DONE; }
// --------------------------------------------------------------------
/** Returns if this request is being prepared. */
bool isPreparing() const { return m_state.getAtomic() == S_PREPARING; }
// --------------------------------------------------------------------
/** Returns if this request is busy. */
bool isBusy() const { return m_state.getAtomic() == S_BUSY; }
// --------------------------------------------------------------------
/** Checks if the request has completed or done (i.e. callbacks were
* executed).
@ -204,8 +221,9 @@ namespace Online
bool hasBeenExecuted() const
{
State s = m_state.getAtomic();
return s==S_EXECUTED || s==S_DONE;
return s == S_EXECUTED || s == S_DONE;
} // hasBeenExecuted
// --------------------------------------------------------------------
/** Virtual method to check if a request has initialized all needed
* members to a valid value. */
@ -226,9 +244,5 @@ namespace Online
}
}; // class Compare
}; // class Request
} //namespace Online
#endif
#endif // HEADER_ONLINE_REQUEST_HPP

35
src/online/request_manager.cpp
View File

@ -111,6 +111,7 @@ namespace Online
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
// Should be the default, but just in case:
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
//pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
@ -118,7 +119,7 @@ namespace Online
m_thread_id.setAtomic(new pthread_t());
int error = pthread_create(m_thread_id.getData(), &attr,
&RequestManager::mainLoop, this);
if(error)
if (error)
{
m_thread_id.lock();
delete m_thread_id.getData();
@ -128,10 +129,11 @@ namespace Online
errno);
}
pthread_attr_destroy(&attr);
// In case that login id was not saved (or first start of stk),
// current player would not be defined at this stage.
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if(player && player->wasOnlineLastTime() &&
if (player && player->wasOnlineLastTime() &&
!UserConfigParams::m_always_show_login_screen)
{
PlayerManager::resumeSavedSession();
@ -178,6 +180,7 @@ namespace Online
request->setBusy();
m_request_queue.lock();
m_request_queue.getData().push(request);
// Wake up the network http thread
pthread_cond_signal(&m_cond_request);
m_request_queue.unlock();
@ -197,27 +200,30 @@ namespace Online
me->m_current_request = NULL;
me->m_request_queue.lock();
while( me->m_request_queue.getData().empty() ||
while (me->m_request_queue.getData().empty() ||
me->m_request_queue.getData().top()->getType() != Request::RT_QUIT)
{
bool empty = me->m_request_queue.getData().empty();
// Wait in cond_wait for a request to arrive. The 'while' is necessary
// since "spurious wakeups from the pthread_cond_wait ... may occur"
// (pthread_cond_wait man page)!
while(empty)
while (empty)
{
pthread_cond_wait(&me->m_cond_request, me->m_request_queue.getMutex());
empty = me->m_request_queue.getData().empty();
}
me->m_current_request = me->m_request_queue.getData().top();
me->m_request_queue.getData().pop();
if(me->m_current_request->getType()==Request::RT_QUIT)
if (me->m_current_request->getType() == Request::RT_QUIT)
break;
me->m_request_queue.unlock();
me->m_current_request->execute();
me->addResult(me->m_current_request);
me->m_request_queue.lock();
} // while
} // while handle all requests
// Signal that the request manager can now be deleted.
// We signal this even before cleaning up memory, since there's no
@ -225,16 +231,18 @@ namespace Online
me->setCanBeDeleted();
// At this stage we have the lock for m_request_queue
while(!me->m_request_queue.getData().empty())
while (!me->m_request_queue.getData().empty())
{
Online::Request * request = me->m_request_queue.getData().top();
Online::Request *request = me->m_request_queue.getData().top();
me->m_request_queue.getData().pop();
// Manage memory can be ignored here, all requests
// need to be freed.
delete request;
}
me->m_request_queue.unlock();
pthread_exit(NULL);
return 0;
} // mainLoop
@ -259,13 +267,13 @@ namespace Online
{
Request * request = NULL;
m_result_queue.lock();
if(!m_result_queue.getData().empty())
if (!m_result_queue.getData().empty())
{
request = m_result_queue.getData().front();
m_result_queue.getData().pop();
}
m_result_queue.unlock();
if(request != NULL)
if (request != NULL)
{
request->callback();
if(request->manageMemory())
@ -298,7 +306,8 @@ namespace Online
float interval = GAME_POLLING_INTERVAL;
if (StateManager::get()->getGameState() == GUIEngine::MENU)
interval = MENU_POLLING_INTERVAL;
if(m_time_since_poll > interval)
if (m_time_since_poll > interval)
{
m_time_since_poll = 0;
PlayerManager::requestOnlinePoll();
@ -306,7 +315,3 @@ namespace Online
} // update
} // namespace Online

20
src/online/request_manager.hpp
View File

@ -39,10 +39,8 @@
#include <queue>
#include <pthread.h>
namespace Online
{
/** A class to execute requests in a separate thread. Typically the
* requests involve a http(s) requests to be sent to the stk server, and
* receive an answer (e.g. to sign in; or to download an addon). The
@ -86,11 +84,14 @@ namespace Online
* grant permission
* IPERM_ALLOWED: STK is allowed to access server.
* IPERM_NOT_ALLOWED: STK must not access external servers. */
enum InternetPermission {IPERM_NOT_ASKED =0,
IPERM_ALLOWED =1,
IPERM_NOT_ALLOWED=2 };
enum InternetPermission
{
IPERM_NOT_ASKED = 0,
IPERM_ALLOWED = 1,
IPERM_NOT_ALLOWED = 2
};
protected:
/** Time passed since the last poll request. */
float m_time_since_poll;
/** The current requested being worked on. */
@ -119,7 +120,7 @@ namespace Online
void addResult(Online::Request *request);
void handleResultQueue();
static void *mainLoop(void *obj);
static void *mainLoop(void *obj);
RequestManager(); //const std::string &url
~RequestManager();
@ -136,12 +137,9 @@ namespace Online
void startNetworkThread();
void stopNetworkThread();
bool getAbort(){ return m_abort.getAtomic(); };
bool getAbort(){ return m_abort.getAtomic(); }
void update(float dt);
}; //class RequestManager
} // namespace Online
#endif // request_manager_HPP
/*EOF*/

8
src/online/server.cpp
View File

@ -24,12 +24,14 @@
#include "utils/constants.hpp"
#include "utils/string_utils.hpp"
namespace Online{
Server::SortOrder Server::m_sort_order=Server::SO_NAME; //FIXME change to some other default
namespace Online
{
Server::SortOrder Server::m_sort_order = Server::SO_NAME;
Server::Server(const XMLNode & xml)
{
assert(xml.getName() == "server");
m_name = "";
m_satisfaction_score = 0;
m_server_id = 0;
@ -45,7 +47,7 @@ namespace Online{
xml.get("max_players", &m_max_players);
xml.get("current_players", &m_current_players);
}; // Server(const XML&)
} // Server(const XML&)
// ----------------------------------------------------------------------------
/**

33
src/online/server.hpp
View File

@ -31,7 +31,8 @@
class XMLNode;
namespace Online{
namespace Online
{
/**
* \ingroup online
*/
@ -40,54 +41,64 @@ namespace Online{
public:
/** Set the sort order used in the comparison function. */
enum SortOrder { SO_SCORE = 1, // Sorted on satisfaction score
SO_NAME = 2, // Sorted alphabetically by name
SO_PLAYERS = 4
enum SortOrder
{
SO_SCORE = 1, // Sorted on satisfaction score
SO_NAME = 2, // Sorted alphabetically by name
SO_PLAYERS = 4
};
protected:
/** The name to be displayed. */
/** The server name to be displayed. */
irr::core::stringw m_name;
std::string m_lower_case_name; //Used for comparison
std::string m_lower_case_name; // Used for comparison
uint32_t m_server_id;
uint32_t m_host_id;
/** The maximum number of players that the server supports */
int m_max_players;
/** The number of players currently on the server */
int m_current_players;
/** The score/rating given */
float m_satisfaction_score;
/** The sort order to be used in the comparison. */
static SortOrder m_sort_order;
Server() {};
Server() {}
public:
/** Initialises the object from an XML node. */
Server(const XMLNode & xml);
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Sets the sort order used in the comparison function. It is static, so
* that each instance can access the sort order. */
static void setSortOrder(SortOrder so) { m_sort_order = so; }
// ------------------------------------------------------------------------
/** Returns the name of the server. */
const irr::core::stringw& getName() const { return m_name; }
const std::string & getLowerCaseName() const { return m_lower_case_name; }
// ------------------------------------------------------------------------
const float getScore() const { return m_satisfaction_score; }
// ------------------------------------------------------------------------
/** Returns the ID of this server. */
const uint32_t getServerId() const { return m_server_id; }
const uint32_t getHostId() const { return m_host_id; }
const int getMaxPlayers() const { return m_max_players; }
const int getCurrentPlayers() const { return m_current_players; }
// ------------------------------------------------------------------------
bool filterByWords(const irr::core::stringw words) const;
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Compares two servers according to the sort order currently defined.
* \param a The addon to compare this addon to.
*/
@ -106,10 +117,10 @@ namespace Online{
return m_current_players < server.getCurrentPlayers();
break;
} // switch
return true;
} // operator<
}; // Server
} // namespace Online
#endif
#endif // HEADER_SERVER_HPP

44
src/online/servers_manager.cpp
View File

@ -16,7 +16,6 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include "online/servers_manager.hpp"
#include <string>
@ -28,14 +27,15 @@
#define SERVER_REFRESH_INTERVAL 5.0f
namespace Online{
namespace Online
{
static ServersManager* manager_singleton(NULL);
ServersManager* ServersManager::get()
{
if (manager_singleton == NULL)
manager_singleton = new ServersManager();
return manager_singleton;
}
@ -46,12 +46,14 @@ namespace Online{
} // deallocate
// ============================================================================
ServersManager::ServersManager(){
ServersManager::ServersManager()
{
m_last_load_time.setAtomic(0.0f);
m_joined_server.setAtomic(NULL);
}
ServersManager::~ServersManager(){
ServersManager::~ServersManager()
{
cleanUpServers();
MutexLocker(m_joined_server);
delete m_joined_server.getData();
@ -75,27 +77,30 @@ namespace Online{
if(StkTime::getRealTime() - m_last_load_time.getAtomic() > SERVER_REFRESH_INTERVAL)
{
request = new RefreshRequest();
request->setServerURL("client-user.php");
request->addParameter("action","get_server_list");
request->setApiURL(API::SERVER_PATH, "get-all");
if (request_now)
RequestManager::get()->addRequest(request);
}
return request;
}
void ServersManager::refresh(bool success, const XMLNode * input)
{
if (success)
if (!success)
{
const XMLNode * servers_xml = input->getNode("servers");
cleanUpServers();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time.setAtomic((float)StkTime::getRealTime());
Log::error("Server Manager", "Could not refresh server list");
return;
}
//FIXME error message
const XMLNode * servers_xml = input->getNode("servers");
cleanUpServers();
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
{
addServer(new Server(*servers_xml->getNode(i)));
}
m_last_load_time.setAtomic((float)StkTime::getRealTime());
}
void ServersManager::RefreshRequest::callback()
@ -117,7 +122,8 @@ namespace Online{
{
MutexLocker(m_joined_server);
delete m_joined_server.getData();
//It's a copy!
// It's a copy!
m_joined_server.getData() = new Server(*getServerByID(id));
}
@ -135,6 +141,7 @@ namespace Online{
m_sorted_servers.lock();
m_sorted_servers.getData().push_back(server);
m_sorted_servers.unlock();
m_mapped_servers.lock();
m_mapped_servers.getData()[server->getServerId()] = server;
m_mapped_servers.unlock();
@ -168,7 +175,8 @@ namespace Online{
}
// ============================================================================
void ServersManager::sort(bool sort_desc){
void ServersManager::sort(bool sort_desc)
{
MutexLocker(m_sorted_servers);
m_sorted_servers.getData().insertionSort(0, sort_desc);
}

21
src/online/servers_manager.hpp
View File

@ -26,11 +26,8 @@
#include "online/xml_request.hpp"
#include "utils/synchronised.hpp"
namespace Online {
namespace Online
{
/**
* \brief
* \ingroup online
@ -51,8 +48,10 @@ namespace Online {
~ServersManager();
/** Sorted vector of servers */
Synchronised<PtrVector<Server> > m_sorted_servers;
/** Maps server id's to the same servers*/
Synchronised<std::map<uint32_t, Server*> > m_mapped_servers;
/** This is a pointer to a copy of the server, the moment it got joined */
Synchronised<Server *> m_joined_server;
@ -74,14 +73,10 @@ namespace Online {
const Server * getServerBySort (int index) const;
void sort(bool sort_desc);
Server * getJoinedServer() const;
//Returns the best server to join
// Returns the best server to join
const Server * getQuickPlay() const;
}; // class ServersManager
} // namespace Online
#endif
/*EOF*/
#endif // HEADER_SERVERS_MANAGER_HPP

15
src/online/xml_request.cpp
View File

@ -24,15 +24,12 @@
#ifdef WIN32
# include <winsock2.h>
#endif
#include <curl/curl.h>
#include <assert.h>
namespace Online
{
/** Creates a HTTP(S) request that will automatically parse the answer into
* a XML structure.
* \param manage_memory whether or not the RequestManager should take care of
@ -61,22 +58,26 @@ namespace Online
void XMLRequest::afterOperation()
{
m_xml_data = file_manager->createXMLTreeFromString(getData());
if(hadDownloadError())
if (hadDownloadError())
{
Log::error("XMLRequest::afterOperation",
"curl_easy_perform() failed: %s",
getDownloadErrorMessage());
}
m_success = false;
std::string rec_success;
if(m_xml_data->get("success", &rec_success))
if (m_xml_data->get("success", &rec_success))
{
m_success = rec_success =="yes";
m_success = (rec_success == "yes");
m_xml_data->get("info", &m_info);
}
else
{
m_info = _("Unable to connect to the server. Check your internet "
"connection or try again later.");
}
HTTPRequest::afterOperation();
} // afterOperation
} // namespace Online

9
src/online/xml_request.hpp
View File

@ -53,7 +53,7 @@ namespace Online
virtual void afterOperation() OVERRIDE;
public :
XMLRequest(bool manage_memory = false, int priority = 1);
XMLRequest(bool manage_memory = false, int priority = 1);
virtual ~XMLRequest();
// ------------------------------------------------------------------------
@ -73,7 +73,7 @@ namespace Online
* \pre request had to be executed.
* \return get the info from the request reply
*/
const irr::core::stringw & getInfo() const
const irr::core::stringw & getInfo() const
{
assert(hasBeenExecuted());
return m_info;
@ -90,8 +90,5 @@ namespace Online
} // isSuccess
}; // class XMLRequest
} //namespace Online
#endif
#endif // HEADER_XML_REQUEST_HPP

2
src/states_screens/create_server_screen.cpp
View File

@ -139,7 +139,7 @@ void CreateServerScreen::serverCreationRequest()
{
m_server_creation_request = new ServerCreationRequest();
PlayerManager::setUserDetails(m_server_creation_request,"create_server");
PlayerManager::setUserDetails(m_server_creation_request, "create", Online::API::SERVER_PATH);
m_server_creation_request->addParameter("name", name);
m_server_creation_request->addParameter("max_players", max_players);
m_server_creation_request->queue();

34
src/states_screens/dialogs/change_password_dialog.cpp
View File

@ -38,8 +38,7 @@ using namespace Online;
/** Creates a modal dialog with given percentage of screen width and height
*/
ChangePasswordDialog::ChangePasswordDialog()
: ModalDialog(0.8f,0.7f)
ChangePasswordDialog::ChangePasswordDialog() : ModalDialog(0.8f, 0.7f)
{
m_self_destroy = false;
m_success = false;
@ -49,15 +48,15 @@ ChangePasswordDialog::ChangePasswordDialog()
m_current_password_widget = getWidget<TextBoxWidget>("current_password");
assert(m_current_password_widget != NULL);
m_current_password_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_current_password_widget->setPasswordBox(true,L'*');
m_current_password_widget->setPasswordBox(true, L'*');
m_new_password1_widget = getWidget<TextBoxWidget>("new_password1");
assert(m_new_password1_widget != NULL);
m_new_password1_widget->setPasswordBox(true,L'*');
m_new_password1_widget->setPasswordBox(true, L'*');
m_new_password2_widget = getWidget<TextBoxWidget>("new_password2");
assert(m_new_password2_widget != NULL);
m_new_password2_widget->setPasswordBox(true,L'*');
m_new_password2_widget->setPasswordBox(true, L'*');
m_info_widget = getWidget<LabelWidget>("info");
assert(m_info_widget != NULL);
@ -71,7 +70,6 @@ ChangePasswordDialog::ChangePasswordDialog()
} // ChangePasswordDialog
// ----------------------------------------------------------------------------
ChangePasswordDialog::~ChangePasswordDialog()
{
} // ~ChangePasswordDialog
@ -93,6 +91,7 @@ void ChangePasswordDialog::changePassword(const stringw &current_password,
virtual void callback()
{
if (!GUIEngine::ModalDialog::isADialogActive()) return;
ChangePasswordDialog * dialog =
dynamic_cast<ChangePasswordDialog*>(GUIEngine::ModalDialog
::getCurrent());
@ -111,8 +110,9 @@ void ChangePasswordDialog::changePassword(const stringw &current_password,
// ------------------------------------------------------------------------
ChangePasswordRequest * request = new ChangePasswordRequest();
PlayerManager::setUserDetails(request, "change_password");
PlayerManager::setUserDetails(request, "change-password");
request->addParameter("current", current_password);
// The server code expects two passwords (and verifies again that they
// are identical), so send the passwod twice.
request->addParameter("new1", new_password);
@ -126,6 +126,7 @@ void ChangePasswordDialog::submit()
const stringw current_password = m_current_password_widget->getText().trim();
const stringw new_password1 = m_new_password1_widget->getText().trim();
const stringw new_password2 = m_new_password2_widget->getText().trim();
if (current_password.size() < 8 || current_password.size() > 30)
{
sfx_manager->quickSound("anvil");
@ -149,6 +150,7 @@ void ChangePasswordDialog::submit()
{
m_options_widget->setDeactivated();
m_info_widget->setDefaultColor();
// We don't need to use password 2 anymore, it was already confirmed
// that both passwords are identical.
changePassword(current_password, new_password1);
@ -159,42 +161,45 @@ void ChangePasswordDialog::submit()
GUIEngine::EventPropagation
ChangePasswordDialog::processEvent(const std::string& eventSource)
{
if (eventSource == m_options_widget->m_properties[PROP_ID])
{
const std::string& selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
m_self_destroy = true;
return GUIEngine::EVENT_BLOCK;
}
else if(selection == m_submit_widget->m_properties[PROP_ID])
{
submit();
return GUIEngine::EVENT_BLOCK;
}
}
return GUIEngine::EVENT_LET;
} // processEvent
// ----------------------------------------------------------------------------
void ChangePasswordDialog::onEnterPressedInternal()
{
const int playerID = PLAYER_ID_GAME_MASTER;
if (GUIEngine::isFocusedForPlayer(m_options_widget, playerID))
return;
if (m_submit_widget->isActivated())
submit();
} // onEnterPressedInternal
// ----------------------------------------------------------------------------
bool ChangePasswordDialog::onEscapePressed()
{
if (m_cancel_widget->isActivated())
m_self_destroy = true;
return false;
} // onEscapePressed
@ -222,12 +227,15 @@ void ChangePasswordDialog::error(const irr::core::stringw & error)
} // error
// -----------------------------------------------------------------------------
void ChangePasswordDialog::onUpdate(float dt)
{
if(!m_options_widget->isActivated())
m_info_widget->setText(StringUtils::loadingDots(_("Validating info")),
false );
{
m_info_widget->setText(
StringUtils::loadingDots(_("Validating info")),
false
);
}
// It's unsafe to delete from inside the event handler so we do it here
if (m_self_destroy)

21
src/states_screens/dialogs/recovery_dialog.cpp
View File

@ -125,9 +125,11 @@ void RecoveryDialog::processInput()
{
m_info_widget->setDefaultColor();
m_options_widget->setDeactivated();
m_recovery_request = new XMLRequest();
// This function also works when the current user is not logged in
PlayerManager::setUserDetails(m_recovery_request, "recovery");
PlayerManager::setUserDetails(m_recovery_request, "recover");
m_recovery_request->addParameter("username", username);
m_recovery_request->addParameter("email", email );
m_recovery_request->queue();
@ -142,10 +144,13 @@ GUIEngine::EventPropagation
{
std::string selection;
if (eventSource == m_options_widget->m_properties[PROP_ID])
selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
{
selection = m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
}
else
{
selection = eventSource;
}
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
@ -165,9 +170,9 @@ GUIEngine::EventPropagation
*/
void RecoveryDialog::onEnterPressedInternal()
{
if (GUIEngine::isFocusedForPlayer(m_options_widget, PLAYER_ID_GAME_MASTER))
return;
if (m_submit_widget->isActivated())
processInput();
}
@ -194,15 +199,19 @@ void RecoveryDialog::onUpdate(float dt)
m_info_widget->setText(m_recovery_request->getInfo(), false);
m_options_widget->setActivated();
}
delete m_recovery_request;
m_recovery_request = NULL;
}
else
{
m_info_widget->setText(StringUtils::loadingDots(_("Validating info")),
false);
m_info_widget->setText(
StringUtils::loadingDots(_("Validating info")),
false
);
}
}
// It's unsafe to delete from inside the event handler so we do it here
if (m_self_destroy)
ModalDialog::dismiss();

1
src/states_screens/dialogs/registration_dialog.cpp
View File

@ -78,6 +78,7 @@ EventPropagation RegistrationDialog::processEvent(const std::string& event_sourc
assert(r);
r->acceptTerms();
}
// If it's not accept, it's cancel - anyway, close dialog
ModalDialog::dismiss();
return EVENT_BLOCK;

29
src/states_screens/dialogs/user_info_dialog.cpp
View File

@ -144,9 +144,10 @@ void UserInfoDialog::sendFriendRequest()
*/
virtual void callback()
{
core::stringw info_text("");
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->addFriend(id);
@ -158,7 +159,10 @@ void UserInfoDialog::sendFriendRequest()
info_text = _("Friend request send!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *dialog = new UserInfoDialog(id, info_text,
!isSuccess(), true);
GUIEngine::DialogQueue::get()->pushDialog(dialog, true);
@ -196,8 +200,9 @@ void UserInfoDialog::acceptFriendRequest()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
OnlineProfile * profile =
@ -211,7 +216,10 @@ void UserInfoDialog::acceptFriendRequest()
info_text = _("Friend request accepted!");
}
else
{
info_text = getInfo();
}
GUIEngine::DialogQueue::get()->pushDialog(
new UserInfoDialog(id, info_text, !isSuccess(), true), true);
@ -225,6 +233,7 @@ void UserInfoDialog::acceptFriendRequest()
PlayerManager::setUserDetails(request, "accept-friend-request");
request->addParameter("friendid", m_online_profile->getID());
request->queue();
m_processing = true;
m_options_widget->setDeactivated();
} // acceptFriendRequest
@ -246,8 +255,9 @@ void UserInfoDialog::declineFriendRequest()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(id);
@ -258,7 +268,10 @@ void UserInfoDialog::declineFriendRequest()
info_text = _("Friend request declined!");
}
else
{
info_text = getInfo();
}
GUIEngine::DialogQueue::get()->pushDialog(
new UserInfoDialog(id, info_text, !isSuccess(),
true), true);
@ -286,9 +299,11 @@ void UserInfoDialog::removeExistingFriend()
class RemoveFriendRequest : public XMLRequest
{
unsigned int m_id;
virtual void callback()
{
core::stringw info_text("");
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(m_id);
@ -299,7 +314,9 @@ void UserInfoDialog::removeExistingFriend()
info_text = _("Friend removed!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *info = new UserInfoDialog(m_id, info_text,
!isSuccess(), true);
@ -335,8 +352,9 @@ void UserInfoDialog::removePendingFriend()
virtual void callback()
{
uint32_t id(0);
getXMLData()->get("friendid", &id);
core::stringw info_text("");
getXMLData()->get("friendid", &id);
if (isSuccess())
{
PlayerManager::getCurrentOnlineProfile()->removeFriend(id);
@ -347,8 +365,9 @@ void UserInfoDialog::removePendingFriend()
info_text = _("Friend request cancelled!");
}
else
{
info_text = getInfo();
}
UserInfoDialog *dia = new UserInfoDialog(id, info_text,
!isSuccess(), true);
GUIEngine::DialogQueue::get()->pushDialog(dia, true);

23
src/states_screens/dialogs/vote_dialog.cpp
View File

@ -48,14 +48,16 @@ VoteDialog::VoteDialog(const std::string & addon_id)
m_rating_widget = getWidget<RatingBarWidget>("rating");
assert(m_rating_widget != NULL);
m_rating_widget->setRating(0);
m_rating_widget->allowVoting();
m_options_widget = getWidget<RibbonWidget>("options");
assert(m_options_widget != NULL);
m_cancel_widget = getWidget<IconButtonWidget>("cancel");
assert(m_cancel_widget != NULL);
m_options_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_options_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
m_fetch_vote_request = new XMLRequest();
PlayerManager::setUserDetails(m_fetch_vote_request, "get-addon-vote");
@ -102,8 +104,9 @@ void VoteDialog::sendVote()
if (isSuccess())
{
std::string addon_id;
getXMLData()->get("addon-id", &addon_id);
float average;
getXMLData()->get("addon-id", &addon_id);
getXMLData()->get("new-average", &average);
addons_manager->getAddon(Addon::createAddonId(addon_id))
->setRating(average);
@ -112,10 +115,8 @@ void VoteDialog::sendVote()
public:
SetAddonVoteRequest() : XMLRequest() {}
}; // SetAddonVoteRequest
// ------------------------------------------------------------------------
m_perform_vote_request = new SetAddonVoteRequest();
PlayerManager::setUserDetails(m_perform_vote_request, "set-addon-vote");
m_perform_vote_request->addParameter("addonid", m_addon_id.substr(6));
@ -144,12 +145,15 @@ GUIEngine::EventPropagation VoteDialog::processEvent(const std::string& event)
{
const std::string& selection =
m_options_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == m_cancel_widget->m_properties[PROP_ID])
{
m_self_destroy = true;
return GUIEngine::EVENT_BLOCK;
}
}
return GUIEngine::EVENT_LET;
} // processEvent
@ -163,16 +167,21 @@ void VoteDialog::updateFetchVote()
if (!m_fetch_vote_request->isDone())
{
// request still pending
m_info_widget->setText(StringUtils::loadingDots(_("Fetching last vote")),
false );
m_info_widget->setText(
StringUtils::loadingDots(_("Fetching last vote")),
false
);
return;
} // !isDone
if (m_fetch_vote_request->isSuccess())
{
m_info_widget->setDefaultColor();
std::string voted("");
m_info_widget->setDefaultColor();
m_fetch_vote_request->getXMLData()->get("voted", &voted);
if (voted == "yes")
{
float rating;

28
src/states_screens/online_screen.cpp
View File

@ -168,36 +168,36 @@ void OnlineScreen::onUpdate(float delta)
void OnlineScreen::doQuickPlay()
{
// Refresh server list.
HTTPRequest* request = ServersManager::get()->refreshRequest(false);
if (request != NULL) // consider request done
HTTPRequest* refresh_request = ServersManager::get()->refreshRequest(false);
if (refresh_request != NULL) // consider request done
{
request->executeNow();
delete request;
refresh_request->executeNow();
delete refresh_request;
}
else
{
Log::error("OnlineScreen", "Could not get the server list.");
return;
}
// select first one
const Server * server = ServersManager::get()->getQuickPlay();
const Server *server = ServersManager::get()->getQuickPlay();
XMLRequest *request2 = new RequestConnection::ServerJoinRequest();
if (!request2)
// do a join request
XMLRequest *join_request = new RequestConnection::ServerJoinRequest();
if (!join_request)
{
sfx_manager->quickSound("anvil");
return;
}
PlayerManager::setUserDetails(request2, "request-connection");
request2->setServerURL("address-management.php");
request2->addParameter("server_id", server->getServerId());
PlayerManager::setUserDetails(join_request, "request-connection", Online::API::SERVER_PATH);
join_request->addParameter("server_id", server->getServerId());
request2->executeNow();
if (request2->isSuccess())
join_request->executeNow();
if (join_request->isSuccess())
{
delete request2;
delete join_request;
StateManager::get()->pushScreen(NetworkingLobby::getInstance());
ConnectToServer *cts = new ConnectToServer(server->getServerId(),
server->getHostId());

16
src/states_screens/online_user_search.cpp
View File

@ -139,25 +139,30 @@ void OnlineUserSearch::parseResult(const XMLNode * input)
{
m_users.clear();
const XMLNode * users_xml = input->getNode("users");
// Try to reserve enough cache space for all found entries.
unsigned int n = ProfileManager::get()
->guaranteeCacheSize(users_xml->getNumNodes());
if (n >= users_xml->getNumNodes())
{
n = users_xml->getNumNodes();
}
else
{
Log::warn("OnlineSearch",
"Too many results found, only %d will be displayed.", n);
}
for (unsigned int i = 0; i < n; i++)
{
OnlineProfile * profile = new OnlineProfile(users_xml->getNode(i));
// The id must be pushed before adding it to the cache, since
// the cache might merge the new data with an existing entry
m_users.push_back(profile->getID());
ProfileManager::get()->addToCache(profile);
}
} // for i = 0 ... number of display users
} // parseResult
// ----------------------------------------------------------------------------
@ -166,17 +171,19 @@ void OnlineUserSearch::parseResult(const XMLNode * input)
void OnlineUserSearch::showList()
{
m_user_list_widget->clear();
for (unsigned int i=0; i < m_users.size(); i++)
for (unsigned int i = 0; i < m_users.size(); i++)
{
std::vector<GUIEngine::ListWidget::ListCell> row;
OnlineProfile * profile = ProfileManager::get()->getProfileByID(m_users[i]);
// This could still happen if something pushed results out of the cache.
if (!profile)
{
Log::warn("OnlineSearch", "User %d not in cache anymore, ignored.",
m_users[i]);
Log::warn("OnlineSearch", "User %d not in cache anymore, ignored.", m_users[i]);
continue;
}
row.push_back(GUIEngine::ListWidget::ListCell(profile->getUserName(),-1,3));
m_user_list_widget->addItem("user", row);
}
@ -267,6 +274,7 @@ void OnlineUserSearch::onUpdate(float dt)
sfx_manager->quickSound( "anvil" );
new MessageDialog(m_search_request->getInfo());
}
delete m_search_request;
m_search_request = NULL;
m_back_widget->setActivated();

12
src/states_screens/register_screen.cpp
View File

@ -72,9 +72,9 @@ void RegisterScreen::init()
getWidget<TextBoxWidget>("local_username")->setText(username);
TextBoxWidget *password_widget = getWidget<TextBoxWidget>("password");
password_widget->setPasswordBox(true,L'*');
password_widget->setPasswordBox(true, L'*');
password_widget = getWidget<TextBoxWidget>("password_confirm");
password_widget->setPasswordBox(true,L'*');
password_widget->setPasswordBox(true, L'*');
m_info_widget = getWidget<LabelWidget>("info");
assert(m_info_widget);
@ -129,6 +129,7 @@ void RegisterScreen::makeEntryFieldsVisible(bool online)
getWidget<LabelWidget>("label_online")->setVisible(false);
online = false;
}
getWidget<TextBoxWidget>("username")->setVisible(online);
getWidget<LabelWidget >("label_username")->setVisible(online);
getWidget<TextBoxWidget>("password")->setVisible(online);
@ -147,7 +148,7 @@ void RegisterScreen::makeEntryFieldsVisible(bool online)
*/
void RegisterScreen::handleLocalName(const stringw &local_name)
{
if (local_name.size()==0)
if (local_name.size() == 0)
return;
// If a local player with that name does not exist, create one
@ -267,9 +268,8 @@ void RegisterScreen::acceptTerms()
core::stringw password_confirm= getWidget<TextBoxWidget>("password_confirm")->getText().trim();
core::stringw email = getWidget<TextBoxWidget>("email")->getText().trim();
m_signup_request = new XMLRequest();
m_signup_request->setServerURL("client-user.php");
m_signup_request->addParameter("action", "register" );
m_signup_request = new XMLRequest();
m_signup_request->setApiURL(API::USER_PATH, "register");
m_signup_request->addParameter("username", username );
m_signup_request->addParameter("password", password );
m_signup_request->addParameter("password_confirm", password_confirm);