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

merged code with upstream master

Browse Source
This commit is contained in:
Rakesh Ranjan Nayak
2014-03-13 22:47:06 +05:30
parent 59e0e3c9be 7e1a59fe99
commit 9b50c9f8bd
27 changed files with 255 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
TODO.md
View File

@@ -20,7 +20,7 @@ no particular order):
- Esp. different platforms
6. Package creators
- Create packages for
- most common Linux Distributors
- most common Linux distributions
- Windows
7. Writers
- Write documentation, ranging from man page, to

4
data/achievements.xml
View File

@@ -22,8 +22,12 @@
<hit goal="5"/>
</achievement>
<achievement id="4" check-type="all-at-least" reset-after-race="yes"
title="Marathoner" description="Make a race with 5 laps or more">
<laps goal="5"/>
<achievement id="5" check-type="all-at-least" reset-after-race="yes"
title="Banana Lover" description="Take at least 5 bananas in one race">
<banana goal="5"/>
</achievement>
</achievements>

5
data/shaders/pass.frag
View File

@@ -1,9 +1,10 @@
#version 330 compatibility
#version 330
uniform sampler2D tex;
in vec2 uv;
out vec4 FragColor;
void main()
{
FragColor = texture(tex, gl_TexCoord[0].xy);
FragColor = texture(tex, uv);
}

8
data/shaders/pass.vert
View File

@@ -1,9 +1,11 @@
// Passthrough shader for drawQuad()
#version 330 compatibility
#version 330
in vec3 Position;
in vec2 Texcoord;
out vec2 uv;
void main() {
uv = gl_MultiTexCoord0.xy;
gl_Position = gl_Vertex;
uv = Texcoord;
gl_Position = vec4(Position, 1.);
}

7
src/achievements/achievement.cpp
View File

@@ -113,10 +113,15 @@ void Achievement::reset()
* The AchievementInfo adds up all goal values to get 'm', and this
* this class end up all current key values for 'n'.
*/
irr::core::stringw Achievement::getProgressAsString()
irr::core::stringw Achievement::getProgressAsString() const
{
int progress = 0;
std::map<std::string, int>::const_iterator iter;
// For now return N/N in case of an achieved achievement.
if (m_achieved)
return getInfo()->toString() +"/" + getInfo()->toString();
switch (m_achievement_info->getCheckType())
{
case AchievementInfo::AC_ALL_AT_LEAST:

2
src/achievements/achievement.hpp
View File

@@ -68,7 +68,7 @@ public:
void increase(const std::string & key, int increase = 1);
virtual void reset();
virtual irr::core::stringw getProgressAsString();
virtual irr::core::stringw getProgressAsString() const;
void onRaceEnd();
// ------------------------------------------------------------------------
/** Returns the id of this achievement. */

3
src/achievements/achievement_info.hpp
View File

@@ -46,7 +46,8 @@ public:
ACHIEVE_FIRST = ACHIEVE_COLUMBUS,
ACHIEVE_STRIKE = 2,
ACHIEVE_ARCH_ENEMY = 3,
ACHIEVE_BANANA = 4,
ACHIEVE_MARATHONER = 4,
ACHIEVE_BANANA = 5,
ACHIEVE_LAST = ACHIEVE_BANANA
};
/** Achievement check type:

6
src/achievements/achievements_status.cpp
View File

@@ -110,7 +110,7 @@ Achievement * AchievementsStatus::getAchievement(uint32_t id)
if ( m_achievements.find(id) != m_achievements.end())
return m_achievements[id];
return NULL;
}
} // getAchievement
// ----------------------------------------------------------------------------
void AchievementsStatus::sync(const std::vector<uint32_t> & achieved_ids)
@@ -121,7 +121,7 @@ void AchievementsStatus::sync(const std::vector<uint32_t> & achieved_ids)
if(achievement != NULL)
achievement->setAchieved();
}
}
} // sync
// ----------------------------------------------------------------------------
void AchievementsStatus::onRaceEnd()
@@ -131,4 +131,4 @@ void AchievementsStatus::onRaceEnd()
for ( iter = m_achievements.begin(); iter != m_achievements.end(); ++iter ) {
iter->second->onRaceEnd();
}
}
} // onRaceEnd

9
src/config/player_profile.cpp
View File

@@ -101,6 +101,15 @@ void PlayerProfile::incrementUseFrequency()
else m_use_frequency++;
} // incrementUseFrequency
// ------------------------------------------------------------------------
/** Notification of a finished race, which can trigger fulfilling
* challenges. */
void PlayerProfile::raceFinished()
{
m_story_mode_status->raceFinished();
m_achievements_status->onRaceEnd();
} // raceFinished
//------------------------------------------------------------------------------
/** Comparison used to sort players.
*/

6
src/config/player_profile.hpp
View File

@@ -77,7 +77,7 @@ public:
void incrementUseFrequency();
bool operator<(const PlayerProfile &other);
bool operator>(const PlayerProfile &other);
void raceFinished();
// ------------------------------------------------------------------------
~PlayerProfile()
@@ -148,10 +148,6 @@ public:
m_story_mode_status->setCurrentChallenge(name);
} // setCurrentChallenge
// ------------------------------------------------------------------------
/** Notification of a finished race, which can trigger fulfilling
* challenges. */
void raceFinished() { m_story_mode_status->raceFinished(); }
// ------------------------------------------------------------------------
/** Callback when a GP is finished (to test if a challenge was
* fulfilled). */
void grandPrixFinished() { m_story_mode_status->grandPrixFinished(); }

8
src/graphics/gpuparticles.cpp
View File

@@ -12,9 +12,8 @@ scene::IParticleSystemSceneNode *ParticleSystemProxy::addParticleNode(
bool withDefaultEmitter, ISceneNode* parent, s32 id,
const core::vector3df& position,
const core::vector3df& rotation,
const core::vector3df& scale) {
if (!irr_driver->isGLSL())
return irr_driver->addParticleNode();
const core::vector3df& scale)
{
if (!parent)
parent = irr_driver->getSceneManager()->getRootSceneNode();
@@ -31,7 +30,8 @@ ParticleSystemProxy::ParticleSystemProxy(bool createDefaultEmitter,
ISceneNode* parent, scene::ISceneManager* mgr, s32 id,
const core::vector3df& position,
const core::vector3df& rotation,
const core::vector3df& scale) : CParticleSystemSceneNode(createDefaultEmitter, parent, mgr, id, position, rotation, scale), m_alpha_additive(false) {
const core::vector3df& scale) : CParticleSystemSceneNode(createDefaultEmitter, parent, mgr, id, position, rotation, scale), m_alpha_additive(false)
{
glGenBuffers(1, &initial_values_buffer);
glGenBuffers(2, tfb_buffers);
glGenBuffers(1, &quaternionsbuffer);

3
src/graphics/gpuparticles.hpp
View File

@@ -9,7 +9,8 @@
namespace irr { namespace video{ class ITexture; } }
class ParticleSystemProxy : public scene::CParticleSystemSceneNode {
class ParticleSystemProxy : public scene::CParticleSystemSceneNode
{
protected:
GLuint tfb_buffers[2], initial_values_buffer, heighmapbuffer, heightmaptexture, quaternionsbuffer;
GLuint current_simulation_vao, non_current_simulation_vao;

78
src/graphics/particle_emitter.cpp
View File

@@ -218,6 +218,36 @@ public:
}; // WindAffector
// ============================================================================
class ScaleAffector : public scene::IParticleAffector
{
public:
ScaleAffector(const core::vector2df& scaleFactor = core::vector2df(1.0f, 1.0f)) : ScaleFactor(scaleFactor)
{
}
virtual void affect(u32 now, scene::SParticle *particlearray, u32 count)
{
for (u32 i = 0; i<count; i++)
{
const u32 maxdiff = particlearray[i].endTime - particlearray[i].startTime;
const u32 curdiff = now - particlearray[i].startTime;
const f32 timefraction = (f32)curdiff / maxdiff;
core::dimension2df destsize = particlearray[i].startSize * ScaleFactor;
particlearray[i].size = particlearray[i].startSize + (destsize - particlearray[i].startSize) * timefraction;
}
}
virtual scene::E_PARTICLE_AFFECTOR_TYPE getType() const
{
return scene::EPAT_SCALE;
}
protected:
core::vector2df ScaleFactor;
};
// ============================================================================
@@ -233,6 +263,8 @@ ParticleEmitter::ParticleEmitter(const ParticleKind* type,
m_particle_type = NULL;
m_parent = parent;
m_emission_decay_rate = 0;
m_is_glsl = irr_driver->isGLSL();
setParticleType(type);
assert(m_node != NULL);
@@ -381,8 +413,12 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
}
else
{
m_node = ParticleSystemProxy::addParticleNode();
if (irr_driver->isGLSL())
if (m_is_glsl)
m_node = ParticleSystemProxy::addParticleNode(m_is_glsl);
else
m_node = irr_driver->addParticleNode();
if (m_is_glsl)
static_cast<ParticleSystemProxy *>(m_node)->setAlphaAdditive(type->getMaterial()->isAlphaAdditive());
}
@@ -550,14 +586,18 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
if (type->hasScaleAffector())
{
core::dimension2df factor = core::dimension2df(type->getScaleAffectorFactorX(),
type->getScaleAffectorFactorY());
scene::IParticleAffector* scale_affector =
m_node->createScaleParticleAffector(factor);
m_node->addAffector(scale_affector);
scale_affector->drop();
if (irr_driver->isGLSL())
if (m_is_glsl)
{
static_cast<ParticleSystemProxy *>(m_node)->setIncreaseFactor(type->getScaleAffectorFactorX());
}
else
{
core::vector2df factor = core::vector2df(type->getScaleAffectorFactorX(),
type->getScaleAffectorFactorY());
scene::IParticleAffector* scale_affector = new ScaleAffector(factor);
m_node->addAffector(scale_affector);
scale_affector->drop();
}
}
const float windspeed = type->getWindSpeed();
@@ -566,14 +606,15 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
WindAffector *waf = new WindAffector(windspeed);
m_node->addAffector(waf);
waf->drop();
}
// TODO: wind affector for GLSL particles
}
const bool flips = type->getFlips();
if (flips)
{
if (irr_driver->isGLSL())
if (m_is_glsl)
static_cast<ParticleSystemProxy *>(m_node)->setFlip();
//m_node->getMaterial(0).BlendOperation = video::EBO_ADD;
}
}
} // setParticleType
@@ -582,10 +623,9 @@ void ParticleEmitter::setParticleType(const ParticleKind* type)
void ParticleEmitter::addHeightMapAffector(Track* t)
{
HeightMapCollisionAffector* hmca = new HeightMapCollisionAffector(t);
m_node->addAffector(hmca);
hmca->drop();
if (irr_driver->isGLSL()) {
if (m_is_glsl)
{
const Vec3* aabb_min;
const Vec3* aabb_max;
t->getAABB(&aabb_min, &aabb_max);
@@ -596,6 +636,12 @@ void ParticleEmitter::addHeightMapAffector(Track* t)
static_cast<ParticleSystemProxy *>(m_node)->setHeightmap(t->buildHeightMap(),
track_x, track_z, track_x_len, track_z_len);
}
else
{
HeightMapCollisionAffector* hmca = new HeightMapCollisionAffector(t);
m_node->addAffector(hmca);
hmca->drop();
}
}
//-----------------------------------------------------------------------------

2
src/graphics/particle_emitter.hpp
View File

@@ -47,6 +47,8 @@ class ParticleEmitter : public NoCopy
{
private:
bool m_is_glsl;
/** Irrlicht's particle systems. */
scene::IParticleSystemSceneNode *m_node;

4
src/graphics/render.cpp
View File

@@ -1007,7 +1007,7 @@ static void getYml(GLenum face, size_t width, size_t height,
static float getTexelValue(unsigned i, unsigned j, size_t width, size_t height, float *Coeff, float *Y00, float *Y1minus1, float *Y10, float *Y11,
float *Y2minus2, float * Y2minus1, float * Y20, float *Y21, float *Y22)
{
float d = sqrt(i * i + j * j + 1);
float d = sqrt((float)(i * i + j * j + 1));
float solidangle = 1.;
size_t idx = i * height + j;
float reconstructedVal = Y00[idx] * Coeff[0];
@@ -1076,7 +1076,7 @@ static void projectSH(float *color[], size_t width, size_t height,
float d = sqrt(fi * fi + fj * fj + 1);
// Constant obtained by projecting unprojected ref values
float solidangle = 2.75 / (wh * pow(d, 1.5));
float solidangle = 2.75 / (wh * pow(d, 1.5f));
float b = color[face][4 * height * i + 4 * j] / 255.;
float g = color[face][4 * height * i + 4 * j + 1] / 255.;
float r = color[face][4 * height * i + 4 * j + 2] / 255.;

25
src/guiengine/skin.cpp
View File

@@ -1222,33 +1222,28 @@ void Skin::drawSpinnerBody(const core::recti &rect, Widget* widget,
}
}
BoxRenderParams& params = (focused || pressed)
? SkinConfig::m_render_params["spinner::focused"]
: SkinConfig::m_render_params["spinner::neutral"];
// defining a spinner widget to use the spinner widget class property(getBackgroundColor)
BoxRenderParams* params;
SpinnerWidget* q = dynamic_cast<SpinnerWidget*>(widget);
if(q->getUseBackgroundColor())
{
int player_id=q->getSpinnerWidgetPlayerID();
if(player_id==0)
params=SkinConfig::m_render_params["spinner1::neutral"];
params=&SkinConfig::m_render_params["spinner1::neutral"];
else if(player_id==1)
params=SkinConfig::m_render_params["spinner2::neutral"];
params=&SkinConfig::m_render_params["spinner2::neutral"];
else if(player_id==2)
params=SkinConfig::m_render_params["spinner3::neutral"];
params=&SkinConfig::m_render_params["spinner3::neutral"];
else if(player_id==3)
params=SkinConfig::m_render_params["spinner4::neutral"];
params=&SkinConfig::m_render_params["spinner4::neutral"];
}
else if (focused|| pressed)
{
params=SkinConfig::m_render_params["spinner::focused"];
params=&SkinConfig::m_render_params["spinner::focused"];
}
else
{
params=SkinConfig::m_render_params["spinner::neutral"];
params=&SkinConfig::m_render_params["spinner::neutral"];
}
if (widget->isFocusedForPlayer(0))
{
core::recti rect2 = rect;
@@ -1313,7 +1308,7 @@ void Skin::drawSpinnerBody(const core::recti &rect, Widget* widget,
- (int)center.Y)*texture_size);
}
drawBoxFromStretchableTexture(widget, sized_rect, params,
drawBoxFromStretchableTexture(widget, sized_rect, *params,
widget->m_deactivated);
@@ -1322,8 +1317,8 @@ void Skin::drawSpinnerBody(const core::recti &rect, Widget* widget,
if (w->isGauge() && !w->m_deactivated)
{
const int handle_size = (int)( widget->m_h*params.m_left_border
/(float)params.getImage()->getSize().Height );
const int handle_size = (int)( widget->m_h*params->m_left_border
/(float)params->getImage()->getSize().Height );
const float value = (float)(w->getValue() - w->getMin())
/ (w->getMax() - w->getMin());

1
src/guiengine/widgets/spinner_widget.cpp
View File

@@ -39,7 +39,6 @@ using namespace irr::video;
SpinnerWidget::SpinnerWidget(const bool gauge) : Widget(WTYPE_SPINNER)
{
m_gauge = gauge;
m_listener = NULL;
m_graphical = false;
m_check_inside_me = true; //FIXME: not sure this is necessary

17
src/guiengine/widgets/spinner_widget.hpp
View File

@@ -57,6 +57,9 @@ namespace GUIEngine
int m_value, m_min, m_max;
int m_spinner_widget_player_id;
bool m_use_background_color;
/** If each value the spinner can take has an associated text, this vector will be non-empty */
std::vector<irr::core::stringw> m_labels;
@@ -69,10 +72,7 @@ namespace GUIEngine
*/
bool m_gauge;
//for setting background
bool m_use_background_color;
int m_spinner_widget_player_id;
/** \brief Whether to wrap back to the first value when going "beyond" the last value */
bool m_wrap_around;
@@ -99,7 +99,7 @@ namespace GUIEngine
irr::video::ITexture* getTexture();
public:
LEAK_CHECK()
SpinnerWidget(const bool gauge=false);
@@ -110,10 +110,11 @@ namespace GUIEngine
void clearLabels();
// next four functions are for background colour behind playername in multikart screen selection
void setUseBackgroundColor() {m_use_background_color=true;}
bool getUseBackgroundColor() {return m_use_background_color;}
void setUseBackgroundColor() {m_use_background_color=true; }
bool getUseBackgroundColor() {return m_use_background_color; }
void setSpinnerWidgetPlayerID(int playerID) {m_spinner_widget_player_id=playerID;}
int getSpinnerWidgetPlayerID() {return m_spinner_widget_player_id;}
int getSpinnerWidgetPlayerID() {return m_spinner_widget_player_id; }
void unsetUseBackgroundColor() {m_use_background_color=false; }

8
src/modes/world.cpp
View File

@@ -443,12 +443,16 @@ void World::terminateRace()
{
updateHighscores(&best_highscore_rank, &best_finish_time, &highscore_who,
&best_player);
PlayerManager::get()->getCurrentPlayer()->raceFinished();
}
PlayerManager::get()->getCurrentPlayer()->raceFinished();
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_COLUMBUS,
getTrack()->getIdent(), 1);
if (raceHasLaps())
{
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_MARATHONER,
"laps", race_manager->getNumLaps());
}
PlayerManager::get()->getCurrentPlayer()->raceFinished();
if (m_race_gui) m_race_gui->clearAllMessages();
// we can't delete the race gui here, since it is needed in case of

15
src/online/current_user.cpp
View File

@@ -63,6 +63,21 @@ namespace Online
delete current_user_singleton;
current_user_singleton = NULL;
} // deallocate
// ------------------------------------------------------------------------
/** Adds the login credential to a http request. A handy static function
* to allow for shorter request creation code. It sets the name of
* the script to invokce, token, and user id.
* \param request The http request.
*/
void CurrentUser::setUserDetails(HTTPRequest *request)
{
CurrentUser *cu = CurrentUser::get();
assert(cu && cu->m_state == US_SIGNED_IN);
assert(cu->m_profile);
request->setServerURL("client-user.php");
request->addParameter("token", cu->m_token);
request->addParameter("userid", cu->m_profile->getID());
} // setUserDetails
// ========================================================================
CurrentUser::CurrentUser()

19
src/online/current_user.hpp
View File

@@ -19,6 +19,8 @@
#ifndef HEADER_CURRENT_ONLINE_USER_HPP
#define HEADER_CURRENT_ONLINE_USER_HPP
#include "online/http_request.hpp"
#include "online/online_profile.hpp"
#include "online/request_manager.hpp"
#include "online/server.hpp"
#include "online/xml_request.hpp"
@@ -166,6 +168,7 @@ namespace Online
/**Singleton */
static CurrentUser * get();
static void deallocate();
static void setUserDetails(HTTPRequest *html);
void requestSavedSession();
SignInRequest * requestSignIn( const irr::core::stringw &username,
@@ -205,14 +208,20 @@ namespace Online
irr::core::stringw getUserName() const;
uint32_t getID() const;
// ----------------------------------------------------------------
/** Returns the user state. */
const UserState getUserState() const { return m_state; }
const UserState getUserState() const { return m_state; }
// ----------------------------------------------------------------
/** Returns whether a user is signed in or not. */
bool isRegisteredUser() const { return m_state == US_SIGNED_IN; }
bool isRegisteredUser() const { return m_state == US_SIGNED_IN; }
// ----------------------------------------------------------------
/** Returns the session token of the signed in user. */
const std::string & getToken() const { return m_token; }
/** Returns a pointer to the profile associated with the current user. */
OnlineProfile * getProfile() const { return m_profile; }
const std::string& getToken() const { return m_token; }
// ----------------------------------------------------------------
/** Returns a pointer to the profile associated with the current
* user. */
OnlineProfile* getProfile() const { return m_profile; }
// ----------------------------------------------------------------
}; // class CurrentUser

8
src/online/online_profile.cpp
View File

@@ -154,10 +154,8 @@ void OnlineProfile::fetchAchievements()
// ------------------------------------------------------------------------
AchievementsRequest * request = new AchievementsRequest();
request->setServerURL("client-user.php");
CurrentUser::setUserDetails(request);
request->addParameter("action", "get-achievements");
request->addParameter("token", CurrentUser::get()->getToken());
request->addParameter("userid", CurrentUser::get()->getID());
request->addParameter("visitingid", m_id);
RequestManager::get()->addRequest(request);
} // fetchAchievements
@@ -209,10 +207,8 @@ void OnlineProfile::fetchFriends()
// ------------------------------------------------------------------------
FriendsListRequest * request = new FriendsListRequest();
request->setServerURL("client-user.php");
CurrentUser::setUserDetails(request);
request->addParameter("action", "get-friends-list");
request->addParameter("token", CurrentUser::get()->getToken());
request->addParameter("userid", CurrentUser::get()->getID());
request->addParameter("visitingid", m_id);
RequestManager::get()->addRequest(request);
} // fetchFriends

8
src/states_screens/kart_selection.cpp
View File

@@ -134,8 +134,6 @@ PlayerNameSpinner::PlayerNameSpinner(KartSelectionScreen* parent,
m_incorrect = false;
m_red_mark_widget = NULL;
m_parent = parent;
m_use_background_color = true;
setUseBackgroundColor();//except for multiplayer kart selection, this is false
setSpinnerWidgetPlayerID(m_player_id);
} // PlayerNameSpinner
@@ -143,7 +141,8 @@ PlayerNameSpinner::PlayerNameSpinner(KartSelectionScreen* parent,
void PlayerNameSpinner::setID(const int m_player_id)
{
PlayerNameSpinner::m_player_id = m_player_id;
} // setID
setSpinnerWidgetPlayerID(m_player_id);
} // setID
// ------------------------------------------------------------------------
/** Add a red mark on the spinner to mean "invalid choice" */
void PlayerNameSpinner::markAsIncorrect()
@@ -178,7 +177,6 @@ void PlayerNameSpinner::markAsCorrect()
m_incorrect = false;
}
} // markAsCorrect
// ============================================================================
#if 0
@@ -382,7 +380,6 @@ PlayerKartWidget::~PlayerKartWidget()
if (m_kart_name->getIrrlichtElement() != NULL)
m_kart_name->getIrrlichtElement()->remove();
getCurrentScreen()->manualRemoveWidget(this);
#ifdef DEBUG
@@ -415,6 +412,7 @@ void PlayerKartWidget::setPlayerID(const int newPlayerID)
// Change the player ID
m_player_id = newPlayerID;
m_player_ident_spinner->setID(m_player_id);
// restore previous focus, but with new player ID
if (focus != NULL) focus->setFocusForPlayer(m_player_id);

2
src/states_screens/kart_selection.hpp
View File

@@ -220,7 +220,7 @@ public:
// ------------------------------------------------------------------------
/** Remove any red mark set with 'markAsIncorrect' */
void markAsCorrect();
void markAsCorrect();
};
/** A widget representing the kart selection for a player (i.e. the player's

111
src/states_screens/online_profile_achievements.cpp
View File

@@ -44,99 +44,138 @@ using namespace Online;
DEFINE_SCREEN_SINGLETON( OnlineProfileAchievements );
// -----------------------------------------------------------------------------
OnlineProfileAchievements::OnlineProfileAchievements() : OnlineProfileBase("online/profile_achievements.stkgui")
/** Constructor.
*/
OnlineProfileAchievements::OnlineProfileAchievements()
: OnlineProfileBase("online/profile_achievements.stkgui")
{
m_selected_achievement_index = -1;
} // OnlineProfileAchievements
// -----------------------------------------------------------------------------
/** Callback when the xml file was loaded.
*/
void OnlineProfileAchievements::loadedFromFile()
{
OnlineProfileBase::loadedFromFile();
m_achievements_list_widget = getWidget<GUIEngine::ListWidget>("achievements_list");
m_achievements_list_widget = getWidget<ListWidget>("achievements_list");
assert(m_achievements_list_widget != NULL);
} // loadedFromFile
// ----------------------------------------------------------------------------
/** Callback before widgets are added. Clears all widgets.
*/
void OnlineProfileAchievements::beforeAddingWidget()
{
OnlineProfileBase::beforeAddingWidget();
m_achievements_list_widget->clearColumns();
m_achievements_list_widget->addColumn( _("Name"), 2 );
if(m_visiting_profile && m_visiting_profile->isCurrentUser())
// For the current player (even if not logged in, i.e. m_visiting_profile
// = NULL) user achievement progress will also be displayed
if(!m_visiting_profile || m_visiting_profile->isCurrentUser())
{
m_achievements_list_widget->addColumn( _("Progress"), 1 );
}
} // beforeAddingWidget
// -----------------------------------------------------------------------------
/** Called when entering this menu (after widgets have been added).
*/
void OnlineProfileAchievements::init()
{
OnlineProfileBase::init();
m_profile_tabs->select( m_achievements_tab->m_properties[PROP_ID], PLAYER_ID_GAME_MASTER );
assert(m_visiting_profile != NULL);
if(m_visiting_profile->isCurrentUser())
m_profile_tabs->select( m_achievements_tab->m_properties[PROP_ID],
PLAYER_ID_GAME_MASTER );
// For current user add the progrss information.
// m_visiting_profile is NULL if the user is not logged in.
if(!m_visiting_profile || m_visiting_profile->isCurrentUser())
{
// No need to wait for results, since they are local anyway
m_waiting_for_achievements = false;
m_achievements_list_widget->clear();
const std::map<uint32_t, Achievement *> & all_achievements =
PlayerManager::get()->getCurrentPlayer()->getAchievementsStatus()
->getAllAchievements();
std::map<uint32_t, Achievement *>::const_iterator it;
for (it = all_achievements.begin(); it != all_achievements.end(); ++it )
for (it = all_achievements.begin(); it != all_achievements.end(); ++it)
{
std::vector<GUIEngine::ListWidget::ListCell> row;
row.push_back(GUIEngine::ListWidget::ListCell(it->second->getInfo()->getTitle(),-1,2));
row.push_back(GUIEngine::ListWidget::ListCell(it->second->getProgressAsString(),-1,1, true));
m_achievements_list_widget->addItem(StringUtils::toString(it->second->getInfo()->getID()), row);
std::vector<ListWidget::ListCell> row;
const Achievement *a = it->second;
ListWidget::ListCell title(a->getInfo()->getTitle(), -1, 2);
ListWidget::ListCell progress(a->getProgressAsString(), -1, 1);
row.push_back(title);
row.push_back(progress);
const std::string id = StringUtils::toString(a->getInfo()->getID());
m_achievements_list_widget->addItem(id, row);
if (a->isAchieved())
m_achievements_list_widget->markItemBlue(id);
}
}
else
{
// Show achievements of a remote user. Set the waiting flag
// and submit a request to get the achievement data.
m_waiting_for_achievements = true;
m_visiting_profile->fetchAchievements();
m_achievements_list_widget->clear();
m_achievements_list_widget->addItem("loading", Messages::fetchingAchievements());
m_achievements_list_widget->addItem("loading",
Messages::fetchingAchievements());
}
} // init
// -----------------------------------------------------------------------------
void OnlineProfileAchievements::eventCallback(Widget* widget, const std::string& name, const int playerID)
void OnlineProfileAchievements::eventCallback(Widget* widget,
const std::string& name,
const int playerID)
{
OnlineProfileBase::eventCallback( widget, name, playerID);
if (name == m_achievements_list_widget->m_properties[GUIEngine::PROP_ID])
{
m_selected_achievement_index = m_achievements_list_widget->getSelectionID();
m_selected_achievement_index =
m_achievements_list_widget->getSelectionID();
int id;
StringUtils::fromString(m_achievements_list_widget->getSelectionInternalName(), id);
new MessageDialog(AchievementsManager::get()->getAchievementInfo(id)->getDescription());
std::string achievement =
m_achievements_list_widget->getSelectionInternalName();
// Convert the achievement number into an integer, and if there
// is no error, show the achievement (it can happen that the
// string is "" if no achievement exists)
if(StringUtils::fromString(achievement, id))
new MessageDialog(AchievementsManager::get()
->getAchievementInfo(id)->getDescription());
}
} // eventCallback
// ----------------------------------------------------------------------------
/** Called every frame. It will check if results from an achievement request
* have been received, and if so, display them.
*/
void OnlineProfileAchievements::onUpdate(float delta)
{
if(m_waiting_for_achievements)
if (!m_waiting_for_achievements) return;
if (!m_visiting_profile->isReady())
{
if(m_visiting_profile->isReady())
{
m_achievements_list_widget->clear();
for(unsigned int i = 0; i < m_visiting_profile->getAchievements().size(); i++)
{
AchievementInfo * info = AchievementsManager::get()->getAchievementInfo(m_visiting_profile->getAchievements()[i]);
m_achievements_list_widget->addItem(StringUtils::toString(info->getID()), info->getTitle());
}
m_waiting_for_achievements = false;
}
else
{
m_achievements_list_widget->renameItem("loading", Messages::fetchingFriends());
}
// This will display an increasing number of dots while waiting.
m_achievements_list_widget->renameItem("loading",
Messages::fetchingAchievements());
return;
}
}
// Now reesults are available, display them.
m_achievements_list_widget->clear();
const OnlineProfile::IDList &a = m_visiting_profile->getAchievements();
for (unsigned int i = 0; i < a.size(); i++)
{
AchievementInfo *info =
AchievementsManager::get()->getAchievementInfo(a[i]);
m_achievements_list_widget->addItem(StringUtils::toString(info->getID()),
info->getTitle() );
}
m_waiting_for_achievements = false;
} // onUpdate

14
src/states_screens/online_profile_base.cpp
View File

@@ -47,9 +47,9 @@ OnlineProfileBase::OnlineProfileBase(const char* filename) : Screen(filename)
*/
void OnlineProfileBase::loadedFromFile()
{
m_profile_tabs = this->getWidget<RibbonWidget>("profile_tabs");
m_profile_tabs = getWidget<RibbonWidget>("profile_tabs");
assert(m_profile_tabs != NULL);
m_header = this->getWidget<LabelWidget>("title");
m_header = getWidget<LabelWidget>("title");
assert(m_header != NULL);
m_overview_tab =
@@ -75,6 +75,13 @@ void OnlineProfileBase::beforeAddingWidget()
m_visiting_profile = ProfileManager::get()->getVisitingProfile();
if (!m_visiting_profile || !m_visiting_profile->isCurrentUser())
m_settings_tab->setVisible(false);
// If not logged in, don't show profile or friends
if (!m_visiting_profile)
{
m_friends_tab->setVisible(false);
m_profile_tabs->setVisible(false);
}
} // beforeAddingWidget
// -----------------------------------------------------------------------------
@@ -89,7 +96,8 @@ void OnlineProfileBase::init()
m_achievements_tab->setTooltip( _("Achievements") );
m_settings_tab->setTooltip( _("Account Settings") );
if (m_visiting_profile && m_visiting_profile->isCurrentUser())
// If no visiting_profile is defined, use the data of the current player.
if (!m_visiting_profile || m_visiting_profile->isCurrentUser())
m_header->setText(_("Your profile"), false);
else if (m_visiting_profile)
{

3
src/states_screens/online_profile_friends.cpp
View File

@@ -105,7 +105,8 @@ void OnlineProfileFriends::eventCallback(Widget* widget,
else if (name == m_friends_list_widget->m_properties[GUIEngine::PROP_ID])
{
int index = m_friends_list_widget->getSelectionID();
new UserInfoDialog(m_visiting_profile->getFriends()[index]);
if (index>-1)
new UserInfoDialog(m_visiting_profile->getFriends()[index]);
}
} // eventCallback