No OneTemporary
Actions

Authored By

Unknown

Size

39 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/StatisticsManager.cpp b/src/StatisticsManager.cpp
	index a507e22..83114d0 100644
	--- a/src/StatisticsManager.cpp
	+++ b/src/StatisticsManager.cpp
	@@ -1,804 +1,822 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include "StatisticsManager.h"
	#include "FileManager.h"
	#include "TreeStorageNode.h"
	#include "POASerializer.h"
	#include "Functions.h"
	#include "LevelPackManager.h"
	#include "MusicManager.h"
	#include "SoundManager.h"
	#include "ThemeManager.h"
	+#include "WordWrapper.h"
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <time.h>
	#include <iostream>
	#include <fstream>
	#include <sstream>
	#include <vector>
	#include <map>
	#include "libs/tinyformat/tinyformat.h"
	#include <SDL_ttf_fontfallback.h>
	#if defined(WIN32)
	#define PRINTF_LONGLONG "%I64d"
	#else
	#define PRINTF_LONGLONG "%lld"
	#endif

	using namespace std;

	StatisticsManager statsMgr;

	static const int achievementDisplayTime=(FPS*4500)/1000;
	static const int achievementIntervalTime=achievementDisplayTime+(FPS*500)/1000;

	static map<string,AchievementInfo*> avaliableAchievements;

	//================================================================

	StatisticsManager::StatisticsManager(){
	bmDropShadow=NULL;
	bmQuestionMark=NULL;
	bmAchievement=NULL;

	startTime=time(NULL);

	tutorialLevels=0;

	clear();
	}

	void StatisticsManager::clear(){
	playerTravelingDistance=shadowTravelingDistance=0.0f;
	playerJumps=shadowJumps
	=playerDies=shadowDies
	=playerSquashed=shadowSquashed
	=completedLevels=silverLevels=goldLevels
	=recordTimes=switchTimes=swapTimes=saveTimes=loadTimes
	=playTime=levelEditTime
	=createdLevels=tutorialCompleted=tutorialGold=0;

	achievements.clear();
	queuedAchievements.clear();

	achievementTime=0;
	currentAchievement=0;
	if(bmAchievement){
	bmAchievement.reset();
	}
	}

	#define LOAD_STATS(var,func) { \
	vector<string> &v=node.attributes[ #var ]; \
	if(!v.empty() && !v[0].empty()) \
	var=func(v[0].c_str()); \
	}

	void StatisticsManager::loadFile(const std::string& fileName){
	clear();

	ifstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;
	POASerializer serializer;
	if(!serializer.readNode(file,&node,true)) return;

	//load statistics
	LOAD_STATS(playerTravelingDistance,atof);
	LOAD_STATS(shadowTravelingDistance,atof);
	LOAD_STATS(playerJumps,atoi);
	LOAD_STATS(shadowJumps,atoi);
	LOAD_STATS(playerDies,atoi);
	LOAD_STATS(shadowDies,atoi);
	LOAD_STATS(playerSquashed,atoi);
	LOAD_STATS(shadowSquashed,atoi);
	LOAD_STATS(recordTimes,atoi);
	LOAD_STATS(switchTimes,atoi);
	LOAD_STATS(swapTimes,atoi);
	LOAD_STATS(saveTimes,atoi);
	LOAD_STATS(loadTimes,atoi);
	LOAD_STATS(playTime,atoi);
	LOAD_STATS(levelEditTime,atoi);
	LOAD_STATS(createdLevels,atoi);

	//load achievements.
	//format is: name;time,name;time,...
	{
	vector<string> &v=node.attributes["achievements"];
	for(unsigned int i=0;i<v.size();i++){
	string s=v[i];
	time_t t=0;

	string::size_type lps=s.find(';');
	if(lps!=string::npos){
	string s1=s.substr(lps+1);
	s=s.substr(0,lps);

	long long n;
	sscanf(s1.c_str(),PRINTF_LONGLONG,&n);

	t=(time_t)n;
	}

	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(s);
	if(it!=avaliableAchievements.end()){
	OwnedAchievement ach={t,it->second};
	achievements[it->first]=ach;
	}
	}
	}
	}

	//Call when level edit is start
	void StatisticsManager::startLevelEdit(){
	levelEditStartTime=time(NULL);
	}

	//Call when level edit is end
	void StatisticsManager::endLevelEdit(){
	levelEditTime+=time(NULL)-levelEditStartTime;
	}

	//update in-game time
	void StatisticsManager::updatePlayTime(){
	time_t endTime=time(NULL);
	playTime+=endTime-startTime;
	startTime=endTime;
	}

	#define SAVE_STATS(var,pattern) { \
	sprintf(s,pattern,var); \
	node.attributes[ #var ].push_back(s); \
	}

	void StatisticsManager::saveFile(const std::string& fileName){
	char s[64];

	//update in-game time
	updatePlayTime();

	ofstream file(fileName.c_str());
	if(!file) return;

	TreeStorageNode node;

	//save statistics
	SAVE_STATS(playerTravelingDistance,"%.2f");
	SAVE_STATS(shadowTravelingDistance,"%.2f");
	SAVE_STATS(playerJumps,"%d");
	SAVE_STATS(shadowJumps,"%d");
	SAVE_STATS(playerDies,"%d");
	SAVE_STATS(shadowDies,"%d");
	SAVE_STATS(playerSquashed,"%d");
	SAVE_STATS(shadowSquashed,"%d");
	SAVE_STATS(recordTimes,"%d");
	SAVE_STATS(switchTimes,"%d");
	SAVE_STATS(swapTimes,"%d");
	SAVE_STATS(saveTimes,"%d");
	SAVE_STATS(loadTimes,"%d");
	SAVE_STATS(playTime,"%d");
	SAVE_STATS(levelEditTime,"%d");
	SAVE_STATS(createdLevels,"%d");

	//save achievements.
	//format is: name;time,name;time,...
	{
	vector<string>& v=node.attributes["achievements"];

	for(map<string,OwnedAchievement>::iterator it=achievements.begin();it!=achievements.end();++it){
	stringstream strm;
	char s[32];

	long long n=it->second.achievedTime;
	sprintf(s,PRINTF_LONGLONG,n);
	strm<<it->first<<";"<<s;

	v.push_back(strm.str());
	}
	}

	POASerializer serializer;
	serializer.writeNode(&node,file,true,true);
	}

	void StatisticsManager::loadPicture(SDL_Renderer& renderer, ImageManager& imageManager){
	//Load drop shadow picture
	bmDropShadow=imageManager.loadTexture(getDataPath()+"gfx/dropshadow.png", renderer);
	bmQuestionMark=imageManager.loadImage(getDataPath()+"gfx/menu/questionmark.png");
	}

	void StatisticsManager::registerAchievements(ImageManager& imageManager){
	if(!avaliableAchievements.empty()) return;

	for(int i=0;achievementList[i].id!=NULL;i++){
	avaliableAchievements[achievementList[i].id]=&achievementList[i];
	if(achievementList[i].imageFile!=NULL){
	achievementList[i].imageSurface = imageManager.loadImage(getDataPath()+achievementList[i].imageFile);
	}
	}
	}

	void StatisticsManager::render(ImageManager&,SDL_Renderer &renderer){
	if(achievementTime==0 && !bmAchievement && currentAchievement<(int)queuedAchievements.size()){
	//create surface
	bmAchievement=createAchievementSurface(renderer, queuedAchievements[currentAchievement++]);
	//FIXME: Draw the box.
	//drawGUIBox(0,0,bmAchievement->w,bmAchievement->h,bmAchievement,0xFFFFFF00);

	//check if queue is empty
	if(currentAchievement>=(int)queuedAchievements.size()){
	queuedAchievements.clear();
	currentAchievement=0;
	}

	//play a sound
	getSoundManager()->playSound("achievement", 1, false, 32);
	}

	//check if we need to display achievements
	if(bmAchievement){
	achievementTime++;
	if(achievementTime<=0){
	return;
	}else if(achievementTime<=5){
	drawAchievement(renderer,achievementTime);
	}else if(achievementTime<=achievementDisplayTime-5){
	drawAchievement(renderer,5);
	}else if(achievementTime<achievementDisplayTime){
	drawAchievement(renderer,achievementDisplayTime-achievementTime);
	}else if(achievementTime>=achievementIntervalTime){
	if(bmAchievement){
	bmAchievement.reset();
	}
	achievementTime=0;
	}
	}
	}

	void StatisticsManager::newAchievement(const std::string& id,bool save){
	//check avaliable achievements
	map<string,AchievementInfo*>::iterator it=avaliableAchievements.find(id);
	if(it==avaliableAchievements.end()) return;

	//check if already have this achievement
	if(save){
	map<string,OwnedAchievement>::iterator it2=achievements.find(id);
	if(it2!=achievements.end()) return;

	OwnedAchievement ach={time(NULL),it->second};
	achievements[id]=ach;
	}

	//add it to queue
	queuedAchievements.push_back(it->second);
	}

	time_t StatisticsManager::achievedTime(const std::string& id) {
	auto it = achievements.find(id);

	if (it == achievements.end()) return 0;
	else return it->second.achievedTime;
	}

	float StatisticsManager::getAchievementProgress(AchievementInfo* info){
	if(!strcmp(info->id,"experienced")){
	return float(completedLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"expert")){
	return float(goldLevels)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"tutorial")){
	if(tutorialLevels>0)
	return float(tutorialCompleted)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	if(!strcmp(info->id,"tutorialGold")){
	if(tutorialLevels>0)
	return float(tutorialGold)/float(tutorialLevels)*100.0f;
	else
	return 0.0f;
	}
	if(!strcmp(info->id,"create10")){
	return float(createdLevels)/10.0f*100.0f;
	}
	if (!strcmp(info->id, "jump100")){
	return float(playerJumps + shadowJumps) / 100.0f*100.0f;
	}
	if (!strcmp(info->id, "jump1k")){
	return float(playerJumps + shadowJumps) / 1000.0f*100.0f;
	}
	if(!strcmp(info->id,"die50")){
	return float(playerDies+shadowDies)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"die1000")){
	return float(playerDies+shadowDies)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"suqash50")){
	return float(playerSquashed+shadowSquashed)/50.0f*100.0f;
	}
	if(!strcmp(info->id,"travel100")){
	return (playerTravelingDistance+shadowTravelingDistance)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"travel1k")){
	return (playerTravelingDistance+shadowTravelingDistance)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel10k")){
	return (playerTravelingDistance+shadowTravelingDistance)/10000.0f*100.0f;
	}
	if(!strcmp(info->id,"travel42k")){
	return (playerTravelingDistance+shadowTravelingDistance)/42195.0f*100.0f;
	}
	if(!strcmp(info->id,"record100")){
	return float(recordTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"record1k")){
	return float(recordTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"switch100")){
	return float(switchTimes)/100.0f*100.0f;
	}
	if(!strcmp(info->id,"switch1k")){
	return float(switchTimes)/1000.0f*100.0f;
	}
	if(!strcmp(info->id,"swap100")){
	return float(swapTimes)/100.0f*100.0f;
	}

	//not found
	return 0.0f;
	}

	SharedTexture StatisticsManager::createAchievementSurface(SDL_Renderer& renderer, AchievementInfo* info,SDL_Rect* rect,bool showTip,const time_t *achievedTime){
	if(info==NULL \|\| info->id==NULL) return NULL;

	//prepare text
	SurfacePtr title0(nullptr);
	SurfacePtr title1(nullptr);
	vector<SDL_Surface*> descSurfaces;
	SDL_Color fg = objThemes.getTextColor(true);
	int fontHeight=TTF_FontLineSkip(fontText);

	bool showDescription=false;
	bool showImage=false;
	float achievementProgress=0.0f;

	if(showTip){
	title0.reset(TTF_RenderUTF8_Blended(fontText,_("New achievement:"),fg));
	title1.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	showDescription=showImage=true;
	}else if(achievedTime){
	char s[256];
	strftime(s,sizeof(s),"%c",localtime(achievedTime));

	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));
	title1.reset(TTF_RenderUTF8_Blended(fontText, tfm::format(_("Achieved on %s"), (char*)s).c_str(), fg));
	showDescription=showImage=true;
	}else if(info->displayStyle==ACHIEVEMENT_HIDDEN){
	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_("Unknown achievement"),fg));
	}else{
	if(info->displayStyle==ACHIEVEMENT_PROGRESS){
	achievementProgress=getAchievementProgress(info);

	title1.reset(TTF_RenderUTF8_Blended(fontText, tfm::format(_("Achieved %1.0f%%"), achievementProgress).c_str(), fg));
	}else{
	title1.reset(TTF_RenderUTF8_Blended(fontText,_("Not achieved"),fg));
	}

	title0.reset(TTF_RenderUTF8_Blended(fontGUISmall,_(info->name),fg));

	showDescription= info->displayStyle==ACHIEVEMENT_ALL \|\| info->displayStyle==ACHIEVEMENT_PROGRESS;
	showImage=true;
	}

	- if(info->description!=NULL && showDescription){
	- string description=_(info->description);
	- string::size_type lps=0,lpe;
	- for(;;){
	- lpe=description.find('\n',lps);
	- if(lpe==string::npos){
	- descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps)+' ').c_str(),fg));
	- break;
	- }else{
	- descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText,(description.substr(lps,lpe-lps)+' ').c_str(),fg));
	- lps=lpe+1;
	- }
	- }
	- }
	-
	//calculate the size
	int w=0,h=0,w1=8,h1=0;

	if(title0!=NULL){
	if(title0->w>w) w=title0->w;
	h1+=title0->h;
	}
	if(title1!=NULL){
	if(title1->w>w) w=title1->w;
	h1+=title1->h;
	/*//calc progress bar size
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	h1+=4;
	}*/
	}

	const int preferredImageWidth = 50;
	const int preferredImageHeight = 50;

	if(showImage){
	if(info->imageSurface!=NULL){
	// NEW: we have the preferred image size
	const int width = std::max(info->r.w, preferredImageWidth);
	const int height = std::max(info->r.h, preferredImageHeight);
	w1+=width+8;
	w+=width+8;
	if(height>h1) h1=height;
	}
	}else{
	w1+=bmQuestionMark->w+8;
	w+=bmQuestionMark->w+8;
	if(bmQuestionMark->h>h1) h1=bmQuestionMark->h;
	}

	+ //we render the description here since we need to know the width of title
	+ if (info->description != NULL && showDescription){
	+ string description = _(info->description);
	+
	+ WordWrapper wrapper;
	+ wrapper.font = fontText;
	+ wrapper.maxWidth = showTip ? std::max(int(SCREEN_WIDTH * 0.5f), w) : (rect ? (rect->w - 16) : -1);
	+ wrapper.wordWrap = wrapper.maxWidth > 0;
	+ wrapper.hyphen = "-";
	+
	+ vector<string> lines;
	+
	+ wrapper.addString(lines, description);
	+
	+ int start, end;
	+ const int m = lines.size();
	+
	+ for (start = 0; start < m; start++) {
	+ if (!lines[start].empty()) break;
	+ }
	+ for (end = m - 1; end >= start; end--) {
	+ if (!lines[end].empty()) break;
	+ }
	+ for (int i = start; i <= end; i++) {
	+ if (lines[i].empty()) {
	+ descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText, " ", fg));
	+ } else {
	+ descSurfaces.push_back(TTF_RenderUTF8_Blended(fontText, lines[i].c_str(), fg));
	+ }
	+ }
	+ }
	+
	h=h1+8;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	if(descSurfaces[i]->w>w) w=descSurfaces[i]->w;
	}
	}
	h+=descSurfaces.size()*fontHeight;
	w+=16;
	h+=16;

	//check if size is specified
	int left=0,top=0;
	if(rect!=NULL){
	//NOTE: SDL2 port. This was never used.
	/* if(surface!=NULL){
	left=rect->x;
	top=rect->y;
	}*/
	if(rect->w>0) w=rect->w;
	else rect->w=w;
	rect->h=h;
	}

	//create surface if necessary
	SurfacePtr surface = createSurface(w, h);
	std::unique_ptr<SDL_Renderer,decltype(&SDL_DestroyRenderer)> surfaceRenderer(
	SDL_CreateSoftwareRenderer(surface.get()), &SDL_DestroyRenderer);

	//draw background
	const SDL_Rect r={left,top,w,h};
	if(showTip \|\| achievedTime){
	SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,255,255,255));
	}else{
	SDL_FillRect(surface.get(),&r,SDL_MapRGB(surface->format,192,192,192));
	}

	//draw horizontal separator
	//FIXME: this is moved from StatisticsScreen::createGUI
	if (!showTip) {
	const SDL_Rect r0 = { left, top, w, 1 };
	const SDL_Rect r1 = { left, top + h - 2, w, 1 };
	const SDL_Rect r2 = { left, top + h - 1, w, 1 };
	Uint32 c0 = achievedTime ? SDL_MapRGB(surface->format, 224, 224, 224) : SDL_MapRGB(surface->format, 168, 168, 168);
	Uint32 c2 = achievedTime ? SDL_MapRGB(surface->format, 128, 128, 128) : SDL_MapRGB(surface->format, 96, 96, 96);
	SDL_FillRect(surface.get(), &r0, c0);
	SDL_FillRect(surface.get(), &r1, c0);
	SDL_FillRect(surface.get(), &r2, c2);
	}

	//draw picture
	if(showImage){
	if(info->imageSurface){
	// NEW: we have the preferred image size
	SDL_Rect r={left+8,top+8+(h1-info->r.h)/2,0,0};
	if (info->r.w < preferredImageWidth) r.x += (preferredImageWidth - info->r.w) / 2;
	SDL_BlitSurface(info->imageSurface,&info->r,surface.get(),&r);
	}
	}else{
	SDL_Rect r={left+8,top+8+(h1-bmQuestionMark->h)/2,0,0};
	SDL_BlitSurface(bmQuestionMark,NULL,surface.get(),&r);
	}

	//draw text
	h=8;
	if(title0){
	SDL_Rect r={left+w1,top+h,0,0};
	SDL_BlitSurface(title0.get(),NULL,surface.get(),&r);
	h+=title0->h;
	}
	if(title1){
	SDL_Rect r={left+w1,top+h,0,0};

	//Draw progress bar.
	if(!showTip && !achievedTime && info->displayStyle==ACHIEVEMENT_PROGRESS){
	//Draw borders.
	SDL_Rect r1={r.x,r.y,w-8-r.x,title1->h};
	drawGUIBox(r1.x,r1.y,r1.w,r1.h,*surfaceRenderer,0x1D);

	//Draw progress.
	r1.x++;
	r1.y++;
	r1.w=int(achievementProgress/100.0f*float(r1.w-2)+0.5f);
	r1.h-=2;

	SDL_SetRenderDrawColor(surfaceRenderer.get(),0,0,0,100);
	SDL_RenderFillRect(surfaceRenderer.get(),&r1);

	//shift the text a little bit (???)
	r.x+=2;
	r.y+=2;
	}

	//Draw text.
	SDL_BlitSurface(title1.get(),NULL,surface.get(),&r);
	}
	h=h1+16;
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	SDL_Rect r={left+8,top+h+static_cast<int>(i)*fontHeight,0,0};
	SDL_BlitSurface(descSurfaces[i],NULL,surface.get(),&r);
	}
	}

	//clean up
	for(unsigned int i=0;i<descSurfaces.size();i++){
	if(descSurfaces[i]!=NULL){
	SDL_FreeSurface(descSurfaces[i]);
	}
	}
	//FIXME: Should we clear the vector here?



	//over
	return textureFromSurface(renderer, std::move(surface));
	}

	void StatisticsManager::drawAchievement(SDL_Renderer& renderer,int alpha){
	if(!bmAchievement \|\| alpha<=0) {
	return;
	}
	if(alpha>5) alpha=5;

	SDL_Rect r = rectFromTexture(*bmAchievement);
	int w=0,h=0;
	SDL_GetRendererOutputSize(&renderer, &w, &h);
	r.x = w-32-r.w;
	r.y = 32;

	SDL_SetTextureAlphaMod(bmAchievement.get(), alpha*40);
	applyTexture(r.x, r.y,bmAchievement, renderer);

	if(!bmDropShadow) {
	return;
	}

	//draw drop shadow - corner
	{
	int w1=r.w/2,w2=r.w-w1,h1=r.h/2,h2=r.h-h1;
	if(w1>16) w1=16;
	if(w2>16) w2=16;
	if(h1>16) h1=16;
	if(h2>16) h2=16;

	const int x=(5-alpha)*64;

	//top-left
	SDL_Rect r1={x,0,w1+16,h1+16};//),r2={r.x-16,r.y-16,0,0};
	SDL_Rect r2 ={r.x-16, r.y-16, r1.w, r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//top-right
	r1.x=x+48-w2;r2.w=r1.w =w2+16;r2.x=r.x+r.w-w2;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-right
	r1.y=48-h2;r2.h=r1.h=h2+16;r2.y=r.y+r.h-h2;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom-left
	r1.x=x;r2.w=r1.w=w1+16;r2.x=r.x-16;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	}
	//draw drop shadow - border
	int i=r.w-32;
	while(i>0){
	const int ii=i>128?128:i;

	//top
	SDL_Rect r1={0,256-alpha*16,ii,16};
	SDL_Rect r2={r.x+r.w-16-i,r.y-16,r1.w,r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.x=128;r2.y=r.y+r.h;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	i=r.h-32;
	while(i>0){
	const int ii=i>128?128:i;

	//top
	SDL_Rect r1={512-alpha*16,0,16,ii};
	SDL_Rect r2={r.x-16,r.y+r.h-16-i, r1.w, r1.h};
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);
	//bottom
	r1.y=128;r2.x=r.x+r.w;
	SDL_RenderCopy(&renderer, bmDropShadow.get(), &r1, &r2);

	i-=ii;
	}
	}

	void StatisticsManager::reloadCompletedLevelsAndAchievements(){
	completedLevels=silverLevels=goldLevels=0;

	LevelPackManager *lpm=getLevelPackManager();
	vector<pair<string,string> > v=lpm->enumLevelPacks();

	bool tutorial=false,tutorialIsGold=false;

	for(unsigned int i=0;i<v.size();i++){
	string& s=v[i].first;
	LevelPack *levels=lpm->getLevelPack(s);
	levels->loadProgress();

	bool b=false;
	if(s==lpm->tutorialLevelPackPath){
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;
	b=tutorial=tutorialIsGold=true;
	}

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	completedLevels++;
	if(b) tutorialCompleted++;
	if(medal==2) silverLevels++;
	if(medal==3){
	goldLevels++;
	if(b) tutorialGold++;
	}

	if(medal!=3 && b) tutorialIsGold=false;
	}else if(b){
	tutorial=tutorialIsGold=false;
	}
	}
	}

	//upadte achievements
	updateLevelAchievements();
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	void StatisticsManager::reloadOtherAchievements(){
	int i;

	if(playTime>=7200) newAchievement("addicted");
	if(playTime>=86400) newAchievement("loyalFan");

	if(levelEditTime>=7200) newAchievement("constructor");
	if(levelEditTime>=28800) newAchievement("constructor2");

	if(createdLevels>=1) newAchievement("create1");
	if(createdLevels>=10) newAchievement("create10");

	i=playerJumps+shadowJumps;
	if (i >= 100) newAchievement("jump100");
	if (i >= 1000) newAchievement("jump1k");

	i=playerDies+shadowDies;
	if(i>=1) newAchievement("die1");
	if(i>=50) newAchievement("die50");
	if(i>=1000) newAchievement("die1000");

	i=playerSquashed+shadowSquashed;
	if(i>=1) newAchievement("squash1");
	if(i>=50) newAchievement("squash50");

	float d=playerTravelingDistance+shadowTravelingDistance;
	if(d>=100.0f) newAchievement("travel100");
	if(d>=1000.0f) newAchievement("travel1k");
	if(d>=10000.0f) newAchievement("travel10k");
	if(d>=42195.0f) newAchievement("travel42k");

	if(recordTimes>=100) newAchievement("record100");
	if(recordTimes>=1000) newAchievement("record1k");

	if(switchTimes>=100) newAchievement("switch100");
	if(switchTimes>=1000) newAchievement("switch1k");

	if(swapTimes>=100) newAchievement("swap100");

	if(saveTimes>=100) newAchievement("save100");

	if(loadTimes>=100) newAchievement("load100");

	if (version.find("Development") != string::npos
	\|\| version.find("Alpha") != string::npos
	\|\| version.find("Beta") != string::npos
	\|\| version.find("RC") != string::npos
	\|\| version.find("Candidate") != string::npos)
	{
	newAchievement("programmer");
	}
	}

	//Update level specified achievements.
	//Make sure the completed level count is correct.
	void StatisticsManager::updateLevelAchievements(){
	if(completedLevels>=1) newAchievement("newbie");
	if(goldLevels>=1) newAchievement("goodjob");
	if(completedLevels>=50) newAchievement("experienced");
	if(goldLevels>=50) newAchievement("expert");
	}

	//Update tutorial specified achievements.
	//Make sure the level progress of tutorial is correct.
	void StatisticsManager::updateTutorialAchievements(){
	//find tutorial level pack
	LevelPackManager *lpm=getLevelPackManager();
	LevelPack *levels=lpm->getTutorialLevelPack();
	if(levels==NULL) return;

	bool tutorial=true,tutorialIsGold=true;
	tutorialLevels=levels->getLevelCount();
	tutorialCompleted=tutorialGold=0;

	for(int n=0,m=levels->getLevelCount();n<m;n++){
	LevelPack::Level *lv=levels->getLevel(n);
	int medal=lv->won;
	if(medal){
	if(lv->targetTime<0 \|\| lv->time<=lv->targetTime)
	medal++;
	if(lv->targetRecordings<0 \|\| lv->recordings<=lv->targetRecordings)
	medal++;

	tutorialCompleted++;

	if(medal!=3) tutorialIsGold=false;
	else tutorialGold++;
	}else{
	tutorial=tutorialIsGold=false;
	break;
	}
	}

	//upadte achievements
	updateTutorialAchievementsInternal((tutorial?1:0)\|(tutorialIsGold?2:0));
	}

	//internal function
	//flags: a bit-field value indicates which achievements we have.
	void StatisticsManager::updateTutorialAchievementsInternal(int flags){
	if(flags&1) newAchievement("tutorial");
	if(flags&2) newAchievement("tutorialGold");
	}
	diff --git a/src/StatisticsScreen.cpp b/src/StatisticsScreen.cpp
	index d7a9acd..0dd719f 100644
	--- a/src/StatisticsScreen.cpp
	+++ b/src/StatisticsScreen.cpp
	@@ -1,416 +1,424 @@
	/*
	* Copyright (C) 2012 Me and My Shadow
	*
	* This file is part of Me and My Shadow.
	*
	* Me and My Shadow is free software: you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation, either version 3 of the License, or
	* (at your option) any later version.
	*
	* Me and My Shadow is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with Me and My Shadow. If not, see <http://www.gnu.org/licenses/>.
	*/

	#include <stdio.h>
	#include <string>
	#include <vector>
	#include <map>
	#include "StatisticsManager.h"
	#include "StatisticsScreen.h"
	#include "Globals.h"
	#include "Functions.h"
	#include "ThemeManager.h"
	#include "InputManager.h"
	#include "GUIListBox.h"
	#include "GUIScrollBar.h"
	#include "EasterEggScreen.h"
	#include <SDL_ttf_fontfallback.h>

	#include "libs/tinyformat/tinyformat.h"

	using namespace std;

	//GUI events are handled here.
	//name: The name of the element that invoked the event.
	//obj: Pointer to the object that invoked the event.
	//eventType: Integer containing the type of event.
	void StatisticsScreen::GUIEventCallback_OnEvent(ImageManager& imageManager, SDL_Renderer& renderer, std::string name,GUIObject* obj,int eventType){
	//Check what type of event it was.
	if(eventType==GUIEventClick){
	if(name=="cmdBack"){
	//Goto the main menu.
	setNextState(STATE_MENU);
	}
	+ } else if (eventType == GUIEventChange && name == "lstAchievements") {
	+ //NOTE: This code is only for testing purpose
	+ int index = lists[0]->value;
	+ if (index >= 0) statsMgr.newAchievement(achievementList[index].id, false);
	+ lists[0]->value = -1;
	}
	}

	//Constructor.
	StatisticsScreen::StatisticsScreen(ImageManager& imageManager, SDL_Renderer& renderer){
	//Update in-game time.
	statsMgr.updatePlayTime();

	//Render the title.
	title = titleTextureFromText(renderer, _("Achievements and Statistics"), objThemes.getTextColor(false), SCREEN_WIDTH);


	//Create GUI.
	createGUI(imageManager, renderer);
	}

	//Destructor.
	StatisticsScreen::~StatisticsScreen(){
	//Delete the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	}

	//we are so lazy that we just use height of the first text, ignore the others
	#define DRAW_PLAYER_STATISTICS(name,var,fmt) { \
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,name,objThemes.getTextColor(true))); \
	SurfacePtr stats = createSurface(w,surface->h); \
	SDL_FillRect(stats.get(),NULL,-1); \
	applySurface(4,0,surface.get(),stats.get(),NULL); \
	y=surface->h; \
	surface.reset(TTF_RenderUTF8_Blended(fontText, \
	tfm::format(fmt,statsMgr.player##var+statsMgr.shadow##var).c_str(), \
	objThemes.getTextColor(true))); \
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	surface.reset(TTF_RenderUTF8_Blended(fontText, \
	tfm::format(fmt,statsMgr.player##var).c_str(), \
	objThemes.getTextColor(true))); \
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	surface.reset(TTF_RenderUTF8_Blended(fontText, \
	tfm::format(fmt,statsMgr.shadow##var).c_str(), \
	objThemes.getTextColor(true))); \
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL); \
	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats))); /* add it to list box */ \
	}

	//Add an item to the listbox, that displays "name1", and "var1" formatted with "format"
	//we are so lazy that we just use height of the first text, ignore the others
	template <class T1>
	static void drawMiscStatistics1(SDL_Renderer& renderer, int w,GUIListBox list,const char name1,const T1 var1,const char* format1){
	//create new surface
	SurfacePtr nameSurface(TTF_RenderUTF8_Blended(fontGUISmall,name1,objThemes.getTextColor(true)));

	SurfacePtr stats=createSurface(w, nameSurface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,nameSurface.get(),stats.get(),NULL);
	const int x=nameSurface->w+8;
	const int y=nameSurface->h;

	SurfacePtr formatSurface(TTF_RenderUTF8_Blended(fontText,
	tfm::format(format1,var1).c_str(),
	objThemes.getTextColor(true)));
	//NOTE: SDL2 port. Not halving the y value here as this ends up looking better.
	applySurface(x,y-formatSurface->h,formatSurface.get(),stats.get(),NULL);

	//add it to list box
	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));

	//over
	//return stats;
	}

	//NOTE: Disabled this for the SDL2 port for now. It looks a bit off anyhow.
	//Might want to make a more general method that draws as many "cells" as there is space.
	//Draws two stats on one line if there is space.
	//we are so lazy that we just use height of the first text, ignore the others
	/*template <class T1,class T2>
	static void drawMiscStatistics2(int w,GUIListBox list,const char name1,const T1 var1,const char* format1,const char* name2,const T2 var2,const char* format2){
	SDL_Surface* stats=drawMiscStatistics1(w,list,name1,var1,format1);

	//Check if the width is enough
	if(w>=800){
	//draw name
	SDL_Surface* surface=TTF_RenderUTF8_Blended(fontGUISmall,name2,objThemes.getTextColor(true));
	applySurface(w/2-8,stats->h-surface->h,surface,stats,NULL);
	int x=surface->w+w/2;
	SDL_FreeSurface(surface);

	//draw value
	char s[1024];
	//FIXME: Use tfm::format instead of sprintf to enable locale support
	FIXME_sprintf(s,format2,var2);
	surface=TTF_RenderUTF8_Blended(fontText,s,objThemes.getTextColor(true));
	applySurface(x,(stats->h-surface->h)/2,surface,stats,NULL);
	SDL_FreeSurface(surface);
	}else{
	//Split into two rows
	drawMiscStatistics1(w,list,name2,var2,format2);
	}
	}*/

	void StatisticsScreen::addAchievements(ImageManager& imageManager, SDL_Renderer &renderer, GUIListBox *list, bool revealUnknownAchievements) {
	for (int idx = 0; achievementList[idx].id != NULL; ++idx) {
	time_t *lpt = NULL;

	map<string, OwnedAchievement>::iterator it = statsMgr.achievements.find(achievementList[idx].id);
	if (it != statsMgr.achievements.end()) {
	lpt = &it->second.achievedTime;
	}

	AchievementInfo info = achievementList[idx];
	if (revealUnknownAchievements) {
	if (info.displayStyle == ACHIEVEMENT_HIDDEN \|\| info.displayStyle == ACHIEVEMENT_TITLE) {
	info.displayStyle = ACHIEVEMENT_ALL;
	}
	}

	SDL_Rect r;
	r.x = r.y = 0;
	r.w = list->width - 16;
	auto surface = statsMgr.createAchievementSurface(renderer, &info, &r, false, lpt);

	if (surface){
	list->addItem(renderer, "", surface);
	}
	}
	}

	//Method that will create the GUI.
	void StatisticsScreen::createGUI(ImageManager& imageManager, SDL_Renderer &renderer){
	//Create the root element of the GUI.
	if(GUIObjectRoot){
	delete GUIObjectRoot;
	GUIObjectRoot=NULL;
	}
	GUIObjectRoot=new GUIObject(imageManager,renderer,0,0,SCREEN_WIDTH,SCREEN_HEIGHT);

	//Create back button.
	GUIObject* obj=new GUIButton(imageManager,renderer,SCREEN_WIDTH*0.5,SCREEN_HEIGHT-60,-1,36,_("Back"),0,true,true,GUIGravityCenter);
	obj->name="cmdBack";
	obj->eventCallback=this;
	GUIObjectRoot->addChild(obj);

	//Create list box.
	listBox=new GUISingleLineListBox(imageManager,renderer,(SCREEN_WIDTH-500)/2,104,500,32);
	listBox->addItem(_("Achievements"));
	listBox->addItem(_("Statistics"));
	listBox->value=0;
	GUIObjectRoot->addChild(listBox);

	//Create list box for achievements.
	GUIListBox *list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72);
	+ list->name = "lstAchievements"; // debug only
	+ list->eventCallback = this; // debug only
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.clear();
	lists.push_back(list);

	addAchievements(imageManager, renderer, list);

	//Now create list box for statistics.
	list=new GUIListBox(imageManager,renderer,64,150,SCREEN_WIDTH-128,SCREEN_HEIGHT-150-72,true,false);
	list->selectable=false;
	GUIObjectRoot->addChild(list);
	lists.push_back(list);

	//Load needed pictures.
	//FIXME: hard-coded image path
	//TODO: Might want to consider not caching these as most other stuff use textures now.
	SDL_Surface* bmPlayer=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/player.png");
	SDL_Surface* bmShadow=imageManager.loadImage(getDataPath()+"themes/Cloudscape/characters/shadow.png");
	SDL_Surface* bmMedal=imageManager.loadImage(getDataPath()+"gfx/medals.png");

	SDL_Rect r;
	int x,y,w=SCREEN_WIDTH-128;
	SharedTexture h_bar = [&](){
	//The horizontal bar.
	SurfacePtr h_bar(createSurface(w,2));
	SDL_Color c = objThemes.getTextColor(true);
	Uint32 clr=SDL_MapRGB(h_bar->format,c.r,c.g,c.b);
	SDL_FillRect(h_bar.get(),NULL,clr);
	return textureFromSurface(renderer, std::move(h_bar));
	}();

	//Player and shadow specific statistics
	//The header.
	{
	SurfacePtr stats = createSurface(w, 44);
	SDL_FillRect(stats.get(),NULL,-1);

	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Total"),objThemes.getTextColor(true)));
	applySurface(w-260-surface->w,stats->h-surface->h,surface.get(),stats.get(),NULL);
	//FIXME: hard-coded player and shadow images
	r.x=0;r.y=0;r.w=23;r.h=40;
	applySurface(w-140-r.w,stats.get()->h-40,bmPlayer,stats.get(),&r);
	applySurface(w-20-r.w,stats.get()->h-40,bmShadow,stats.get(),&r);

	list->addItem(renderer, "",textureFromSurface(renderer, std::move(stats)));
	}

	//Each items.
	{
	DRAW_PLAYER_STATISTICS(_("Traveling distance (m)"),TravelingDistance,"%0.1f");
	DRAW_PLAYER_STATISTICS(_("Jump times"),Jumps,"%d");
	DRAW_PLAYER_STATISTICS(_("Die times"),Dies,"%d");
	DRAW_PLAYER_STATISTICS(_("Squashed times"),Squashed,"%d");
	}

	//Game specific statistics.
	list->addItem(renderer, "",h_bar);

	auto drawMiscStats = [&](const char* name1,const int var1,const char* format1) {
	drawMiscStatistics1(renderer, w, list, name1, var1, format1);
	};

	drawMiscStats(_("Recordings:"),statsMgr.recordTimes,"%d");
	drawMiscStats(_("Switch pulled times:"),statsMgr.switchTimes,"%d");
	drawMiscStats(_("Swap times:"),statsMgr.swapTimes,"%d");
	drawMiscStats(_("Save times:"),statsMgr.saveTimes,"%d");
	drawMiscStats(_("Load times:"),statsMgr.loadTimes,"%d");

	//Level specific statistics
	list->addItem(renderer, "",h_bar);
	{
	SurfacePtr surface(TTF_RenderUTF8_Blended(fontGUISmall,_("Completed levels:"),objThemes.getTextColor(true)));
	SurfacePtr stats = createSurface(w, surface->h);
	SDL_FillRect(stats.get(),NULL,-1);

	applySurface(4,0,surface.get(),stats.get(),NULL);
	x=surface->w+8;
	y=surface->h;

	surface.reset(TTF_RenderUTF8_Blended(fontText,
	tfm::format("%d", statsMgr.completedLevels).c_str(),
	objThemes.getTextColor(true)));

	applySurface(x,(y-surface->h),surface.get(),stats.get(),NULL);

	surface.reset(TTF_RenderUTF8_Blended(fontText,
	tfm::format("%d", statsMgr.completedLevels - statsMgr.goldLevels - statsMgr.silverLevels).c_str(),
	objThemes.getTextColor(true)));
	applySurface(w-260-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x=0;r.y=0;r.w=30;r.h=30;
	applySurface(w-260-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	surface.reset(TTF_RenderUTF8_Blended(fontText,
	tfm::format("%d", statsMgr.silverLevels).c_str(),
	objThemes.getTextColor(true)));
	applySurface(w-140-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-140-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	surface.reset(TTF_RenderUTF8_Blended(fontText,
	tfm::format("%d", statsMgr.goldLevels).c_str(),
	objThemes.getTextColor(true)));
	applySurface(w-20-surface->w,(y-surface->h)/2,surface.get(),stats.get(),NULL);
	r.x+=30;
	applySurface(w-20-surface->w-30,(y-30)/2,bmMedal,stats.get(),&r);

	list->addItem(renderer,"",textureFromSurface(renderer, std::move(stats)));
	}

	//Other statistics.
	list->addItem(renderer, "",h_bar);

	drawMiscStatistics1(renderer,w,list,_("In-game time:"),
	tfm::format("%02d:%02d:%02d", statsMgr.playTime / 3600, (statsMgr.playTime / 60) % 60, statsMgr.playTime % 60),
	"%s");
	drawMiscStatistics1(renderer,w,list,_("Level editing time:"),
	tfm::format("%02d:%02d:%02d", statsMgr.levelEditTime / 3600, (statsMgr.levelEditTime / 60) % 60, statsMgr.levelEditTime % 60),
	"%s");

	drawMiscStats(_("Created levels:"),statsMgr.createdLevels,"%d");
	}

	//In this method all the key and mouse events should be handled.
	//NOTE: The GUIEvents won't be handled here.
	void StatisticsScreen::handleEvents(ImageManager& imageManager, SDL_Renderer& renderer){
	//Check if we need to quit, if so enter the exit state.
	if(event.type==SDL_QUIT){
	setNextState(STATE_EXIT);
	}

	//Check horizontal movement
	int value = listBox->value;
	if (inputMgr.isKeyDownEvent(INPUTMGR_RIGHT)){
	isKeyboardOnly = true;
	value++;
	if (value >= (int)listBox->item.size()) value = 0;
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_LEFT)){
	isKeyboardOnly = true;
	value--;
	if (value < 0) value = listBox->item.size() - 1;
	}
	listBox->value = value;

	//Check vertical movement
	if (value >= 0 && value < (int)lists.size()) {
	if (inputMgr.isKeyDownEvent(INPUTMGR_UP)){
	isKeyboardOnly = true;
	lists[value]->scrollScrollbar(-1);
	} else if (inputMgr.isKeyDownEvent(INPUTMGR_DOWN)){
	isKeyboardOnly = true;
	lists[value]->scrollScrollbar(1);
	}
	}

	//Yet another cheat "ls -la" which reveals all unknown achievements
	static char input[6];
	static int inputLen = 0;
	if (value == 0) {
	if (event.type == SDL_KEYDOWN) {
	if (event.key.keysym.sym >= 32 && event.key.keysym.sym <= 126) {
	if (inputLen < sizeof(input)) input[inputLen] = event.key.keysym.sym;
	inputLen++;
	} else {
	if (event.key.keysym.sym == SDLK_RETURN && inputLen == 6 &&
	input[0] == 'l' && input[1] == 's' && input[2] == ' ' && input[3] == '-' && input[4] == 'l' && input[5] == 'a')
	{
	if (easterEggScreen(imageManager, renderer)) {
	//new achievement
	statsMgr.newAchievement("cheat");

	//reload achievement list with hidden achievements revealed
	lists[0]->clearItems();
	+ lists[0]->selectable = true; // debug only
	addAchievements(imageManager, renderer, lists[0], true);
	}
	}
	inputLen = 0;
	}
	}
	} else {
	inputLen = 0;
	}

	//Check if the escape button is pressed, if so go back to the main menu.
	if(inputMgr.isKeyDownEvent(INPUTMGR_ESCAPE)){
	setNextState(STATE_MENU);
	}
	}

	//All the logic that needs to be done should go in this method.
	void StatisticsScreen::logic(ImageManager&, SDL_Renderer&){
	}

	//This method handles all the rendering.
	void StatisticsScreen::render(ImageManager&, SDL_Renderer& renderer){
	//Draw background.
	objThemes.getBackground(true)->draw(renderer);
	objThemes.getBackground(true)->updateAnimation();

	//Draw title.
	drawTitleTexture(SCREEN_WIDTH, *title, renderer);

	//Draw statistics.
	int value=listBox->value;
	for(unsigned int i=0;i<lists.size();i++){
	lists[i]->visible=(i==value);
	}
	}

	//Method that will be called when the screen size has been changed in runtime.
	void StatisticsScreen::resize(ImageManager &imageManager, SDL_Renderer &renderer){
	//Recreate the gui to fit the new resolution.
	createGUI(imageManager, renderer);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, May 9, 8:05 PM (6 d, 20 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 62880
Default Alt Text: (39 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions