Marown/swad-core
Marown
/
swad-core
mirror of https://github.com/acanas/swad-core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
swad-core/swad_match.c

2363 lines
80 KiB
C
Raw Normal View History

Version19.1
2019-09-14 12:59:34 +02:00
// swad_match.c: matches in games using remote control
/*
SWAD (Shared Workspace At a Distance),
is a web platform developed at the University of Granada (Spain),
and used to support university teaching.
This file is part of SWAD core.
Copyright (C) 1999-2019 Antonio Ca<EFBFBD>as Vargas
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This program 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*****************************************************************************/
/********************************* Headers ***********************************/
/*****************************************************************************/
#define _GNU_SOURCE // For asprintf
#include <linux/limits.h> // For PATH_MAX
#include <linux/stddef.h> // For NULL
#include <stdio.h> // For asprintf
#include <stdlib.h> // For calloc
#include <string.h> // For string functions
#include "swad_alert.h"
#include "swad_box.h"
#include "swad_database.h"
#include "swad_form.h"
#include "swad_game.h"
#include "swad_global.h"
#include "swad_group.h"
#include "swad_match.h"
#include "swad_pagination.h"
#include "swad_parameter.h"
#include "swad_role.h"
#include "swad_setting.h"
#include "swad_table.h"
#include "swad_test.h"
/*****************************************************************************/
/************** External global variables from others modules ****************/
/*****************************************************************************/
extern struct Globals Gbl;
/*****************************************************************************/
/***************************** Private constants *****************************/
/*****************************************************************************/
#define Mch_ICON_CLOSE "fas fa-times"
#define Mch_ICON_PLAY "fas fa-play"
#define Mch_ICON_PAUSE "fas fa-pause"
#define Mch_ICON_PREVIOUS "fas fa-step-backward"
#define Mch_ICON_NEXT "fas fa-step-forward"
#define Mch_ICON_RESULTS "fas fa-chart-bar"
/*****************************************************************************/
/******************************* Private types *******************************/
/*****************************************************************************/
Version19.2
2019-09-14 19:46:26 +02:00
#define Mch_NUM_SHOWING 3
Version19.1
2019-09-14 12:59:34 +02:00
typedef enum
{
Version19.3
2019-09-16 00:15:40 +02:00
Mch_STEM, // Showing only the question stem
Mch_ANSWERS, // Showing the question stem and the answers
Version19.1
2019-09-14 12:59:34 +02:00
Mch_RESULTS, // Showing the results
} Mch_Showing_t;
Version19.3
2019-09-16 00:15:40 +02:00
#define Mch_SHOWING_DEFAULT Mch_STEM
Version19.1
2019-09-14 12:59:34 +02:00
struct Match
{
long MchCod;
long GamCod;
long UsrCod;
time_t TimeUTC[2];
char Title[Gam_MAX_BYTES_TITLE + 1];
struct
{
unsigned QstInd; // 0 means that the game has not started. First question has index 1.
long QstCod;
time_t QstStartTimeUTC;
Version19.2
2019-09-14 19:46:26 +02:00
bool ShowResults;
Version19.1
2019-09-14 12:59:34 +02:00
Mch_Showing_t Showing;
bool BeingPlayed;
unsigned NumPlayers;
} Status;
};
/*****************************************************************************/
/***************************** Private constants *****************************/
/*****************************************************************************/
const char *Mch_ShowingStringsDB[Mch_NUM_SHOWING] =
{
Version19.3
2019-09-16 00:15:40 +02:00
"stem",
Version19.1
2019-09-14 12:59:34 +02:00
"answers",
"results",
};
/*****************************************************************************/
/***************************** Private variables *****************************/
/*****************************************************************************/
long Mch_CurrentMchCod = -1L; // Used as parameter in contextual links
/*****************************************************************************/
/***************************** Private prototypes ****************************/
/*****************************************************************************/
static void Mch_GetDataOfMatchByCod (struct Match *Match);
static void Mch_PutIconToPlayNewMatch (void);
static void Mch_ListOneOrMoreMatches (struct Game *Game,
unsigned NumMatches,
MYSQL_RES *mysql_res);
static void Mch_GetAndWriteNamesOfGrpsAssociatedToMatch (struct Match *Match);
static void Mch_GetMatchDataFromRow (MYSQL_RES *mysql_res,
struct Match *Match);
static Mch_Showing_t Mch_GetShowingFromStr (const char *Str);
static void Mch_PutParamCurrentMchCod (void);
static void Mch_PutParamMatchCod (long MchCod);
static long Mch_GetParamMatchCod (void);
static void Mch_PutButtonNewMatch (long GamCod);
static void Mch_PutFormNewMatch (struct Game *Game);
static void Mch_ShowLstGrpsToCreateMatch (void);
static long Mch_CreateMatch (long GamCod,char Title[Gam_MAX_BYTES_TITLE + 1]);
static void Mch_CreateGrps (long MchCod);
static void Mch_UpdateMatchStatusInDB (struct Match *Match);
static void Mch_UpdateElapsedTimeInQuestion (struct Match *Match);
static void Mch_GetElapsedTimeInQuestion (struct Match *Match,
struct Time *Time);
static void Mch_GetElapsedTimeInMatch (struct Match *Match,
struct Time *Time);
static void Mch_GetElapsedTime (unsigned NumRows,MYSQL_RES *mysql_res,
struct Time *Time);
static void Mch_SetMatchStatusToPrev (struct Match *Match);
static void Mch_SetMatchStatusToNext (struct Match *Match);
static void Mch_ShowMatchStatusForTch (struct Match *Match);
static void Mch_ShowMatchStatusForStd (struct Match *Match);
static bool Mch_CheckIfIPlayThisMatchBasedOnGrps (long MchCod);
static void Mch_ShowLeftColumnTch (struct Match *Match);
static void Mch_ShowLeftColumnStd (struct Match *Match);
static void Mch_ShowNumQstInMatch (struct Match *Match);
Version19.2
2019-09-14 19:46:26 +02:00
static void Mch_PutMatchControlButtons (struct Match *Match);
static void Mch_PutCheckboxResult (struct Match *Match);
Version19.1
2019-09-14 12:59:34 +02:00
static void Mch_ShowNumPlayers (struct Match *Match);
static void Mch_ShowMatchTitle (struct Match *Match);
static void Mch_ShowQuestionAndAnswersTch (struct Match *Match);
static void Mch_ShowQuestionAndAnswersStd (struct Match *Match);
static void Mch_PutParamAnswer (unsigned AnsInd);
static unsigned Mch_GetParamAnswer (void);
static void Mch_PutBigButton (Act_Action_t NextAction,long MchCod,
const char *Icon,const char *Txt);
static void Mch_PutBigButtonOff (const char *Icon);
static void Mch_PutBigButtonClose (void);
static void Mch_ShowWaitImage (const char *Txt);
static void Mch_RemoveOldPlayers (void);
static void Mch_UpdateMatchAsBeingPlayed (long MchCod);
static void Mch_SetMatchAsNotBeingPlayed (long MchCod);
static bool Mch_GetIfMatchIsBeingPlayed (long MchCod);
static void Mch_RegisterMeAsPlayerInMatch (long MchCod);
static void Mch_GetNumPlayers (struct Match *Match);
static int Mch_GetQstAnsFromDB (long MchCod,unsigned QstInd);
Version19.3
2019-09-16 00:15:40 +02:00
static unsigned Mch_GetNumUsrsWhoHaveChosenAns (long MchCod,unsigned QstInd,unsigned AnsInd);
static void Mch_DrawBarNumUsrs (unsigned NumAnswerersAns,unsigned NumAnswerersQst,bool Correct);
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
/************************* List the matches of a game ************************/
/*****************************************************************************/
void Mch_ListMatches (struct Game *Game,bool PutFormNewMatch)
{
extern const char *Hlp_ASSESSMENT_Games_matches;
extern const char *Txt_Matches;
extern long Gam_CurrentGamCod; // Used as parameter in contextual links;
char *SubQuery;
MYSQL_RES *mysql_res;
unsigned NumMatches;
/***** Get data of matches from database *****/
/* Fill subquery for game */
if (Gbl.Crs.Grps.WhichGrps == Grp_ONLY_MY_GROUPS)
{
if (asprintf (&SubQuery," AND"
"(MchCod NOT IN"
Version19.4
2019-09-17 01:37:07 +02:00
" (SELECT MchCod FROM mch_groups)"
Version19.1
2019-09-14 12:59:34 +02:00
" OR"
" MchCod IN"
Version19.4
2019-09-17 01:37:07 +02:00
" (SELECT mch_groups.MchCod"
" FROM mch_groups,crs_grp_usr"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE crs_grp_usr.UsrCod=%ld"
Version19.4
2019-09-17 01:37:07 +02:00
" AND mch_groups.GrpCod=crs_grp_usr.GrpCod))",
Version19.1
2019-09-14 12:59:34 +02:00
Gbl.Usrs.Me.UsrDat.UsrCod) < 0)
Lay_NotEnoughMemoryExit ();
}
else // Gbl.Crs.Grps.WhichGrps == Grp_ALL_GROUPS
if (asprintf (&SubQuery,"%s","") < 0)
Lay_NotEnoughMemoryExit ();
/* Make query */
NumMatches = (unsigned) DB_QuerySELECT (&mysql_res,"can not get matches",
Version19.2
2019-09-14 19:46:26 +02:00
"SELECT MchCod," // row[ 0]
"GamCod," // row[ 1]
"UsrCod," // row[ 2]
"UNIX_TIMESTAMP(StartTime)," // row[ 3]
"UNIX_TIMESTAMP(EndTime)," // row[ 4]
"Title," // row[ 5]
"QstInd," // row[ 6]
"QstCod," // row[ 7]
"UNIX_TIMESTAMP(QstStartTime)," // row[ 8]
"ShowResults," // row[ 9]
"Showing" // row[10]
Version19.4
2019-09-17 01:37:07 +02:00
" FROM mch_matches"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE GamCod=%ld%s"
" ORDER BY MchCod",
Game->GamCod,
SubQuery);
/* Free allocated memory for subquery */
free ((void *) SubQuery);
/***** Start box *****/
Gam_CurrentGamCod = Game->GamCod;
Box_StartBox (NULL,Txt_Matches,Mch_PutIconToPlayNewMatch,
Hlp_ASSESSMENT_Games_matches,Box_NOT_CLOSABLE);
if (NumMatches)
/***** Show the table with the matches *****/
Mch_ListOneOrMoreMatches (Game,NumMatches,mysql_res);
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
/***** Put button to play a new match in this game *****/
switch (Gbl.Usrs.Me.Role.Logged)
{
case Rol_NET:
case Rol_TCH:
case Rol_SYS_ADM:
if (PutFormNewMatch)
Mch_PutFormNewMatch (Game); // Form to fill in data and start playing a new match
else
Mch_PutButtonNewMatch (Game->GamCod); // Button to create a new match
break;
default:
break;
}
/***** End box *****/
Box_EndBox ();
}
/*****************************************************************************/
/********************** Get match data using its code ************************/
/*****************************************************************************/
static void Mch_GetDataOfMatchByCod (struct Match *Match)
{
MYSQL_RES *mysql_res;
unsigned long NumRows;
/***** Get data of match from database *****/
NumRows = (unsigned) DB_QuerySELECT (&mysql_res,"can not get matches",
Version19.2
2019-09-14 19:46:26 +02:00
"SELECT MchCod," // row[ 0]
"GamCod," // row[ 1]
"UsrCod," // row[ 2]
"UNIX_TIMESTAMP(StartTime)," // row[ 3]
"UNIX_TIMESTAMP(EndTime)," // row[ 4]
"Title," // row[ 5]
"QstInd," // row[ 6]
"QstCod," // row[ 7]
"UNIX_TIMESTAMP(QstStartTime)," // row[ 8]
"ShowResults," // row[ 9]
"Showing" // row[10]
Version19.4
2019-09-17 01:37:07 +02:00
" FROM mch_matches"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld"
" AND GamCod IN" // Extra check
Version19.4
2019-09-17 01:37:07 +02:00
" (SELECT GamCod FROM gam_games"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE CrsCod='%ld')",
Match->MchCod,
Gbl.Hierarchy.Crs.CrsCod);
if (NumRows) // Match found...
/***** Get match data from row *****/
Mch_GetMatchDataFromRow (mysql_res,Match);
else
{
/* Initialize to empty match */
Match->MchCod = -1L;
Match->GamCod = -1L;
Match->UsrCod = -1L;
Match->TimeUTC[Gam_START_TIME] =
Match->TimeUTC[Gam_END_TIME ] = (time_t) 0;
Match->Title[0] = '\0';
Match->Status.QstInd = 0;
Match->Status.QstCod = -1L;
Match->Status.QstStartTimeUTC = (time_t) 0;
Version19.2
2019-09-14 19:46:26 +02:00
Match->Status.ShowResults = true;
Version19.3
2019-09-16 00:15:40 +02:00
Match->Status.Showing = Mch_STEM;
Version19.1
2019-09-14 12:59:34 +02:00
Match->Status.BeingPlayed = false;
}
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/***************** Put icon to add a new questions to game *******************/
/*****************************************************************************/
static void Mch_PutIconToPlayNewMatch (void)
{
extern const char *Txt_New_match;
/***** Put form to create a new question *****/
Ico_PutContextualIconToAdd (ActReqNewMchTch,Mch_NEW_MATCH_SECTION_ID,Gam_PutParams,
Txt_New_match);
}
/*****************************************************************************/
/*********************** List game matches for edition ***********************/
/*****************************************************************************/
static void Mch_ListOneOrMoreMatches (struct Game *Game,
unsigned NumMatches,
MYSQL_RES *mysql_res)
{
extern const char *Txt_No_INDEX;
extern const char *Txt_ROLES_SINGUL_Abc[Rol_NUM_ROLES][Usr_NUM_SEXS];
extern const char *Txt_START_END_TIME[Dat_NUM_START_END_TIME];
extern const char *Txt_Match;
extern const char *Txt_Status;
extern const char *Txt_Play;
extern const char *Txt_Resume;
extern const char *Txt_Today;
unsigned NumMatch;
unsigned UniqueId;
struct Match Match;
/***** Write the heading *****/
Tbl_StartTableWideMargin (2);
fprintf (Gbl.F.Out,"<tr>"
"<th></th>"
"<th class=\"RIGHT_TOP\">"
"%s"
"</th>"
"<th class=\"LEFT_TOP\">"
"%s"
"</th>"
"<th class=\"LEFT_TOP\">"
"%s"
"</th>"
"<th class=\"LEFT_TOP\">"
"%s"
"</th>"
"<th class=\"LEFT_TOP\">"
"%s"
"</th>"
"<th class=\"RIGHT_TOP\">"
"%s"
"</th>"
"</tr>",
Txt_No_INDEX,
Txt_ROLES_SINGUL_Abc[Rol_TCH][Usr_SEX_UNKNOWN],
Txt_START_END_TIME[Gam_ORDER_BY_START_DATE],
Txt_START_END_TIME[Gam_ORDER_BY_END_DATE],
Txt_Match,
Txt_Status);
/***** Write rows *****/
for (NumMatch = 0, UniqueId = 1;
NumMatch < NumMatches;
NumMatch++, UniqueId++)
{
Gbl.RowEvenOdd = NumMatch % 2;
/***** Get match data from row *****/
Mch_GetMatchDataFromRow (mysql_res,&Match);
/***** Icons *****/
fprintf (Gbl.F.Out,"<tr>"
"<td class=\"BT%u\">",Gbl.RowEvenOdd);
/* Put icon to remove the match */
Frm_StartForm (ActReqRemMchTch);
Mch_PutParamMatchCod (Match.MchCod);
Ico_PutIconRemove ();
Frm_EndForm ();
fprintf (Gbl.F.Out,"</td>");
/***** Number of match ******/
fprintf (Gbl.F.Out,"<td class=\"BIG_INDEX RIGHT_TOP COLOR%u\">%u</td>",
Gbl.RowEvenOdd,NumMatch + 1);
/***** Match player *****/
fprintf (Gbl.F.Out,"<td class=\"LEFT_TOP COLOR%u\">",
Gbl.RowEvenOdd);
Usr_WriteAuthor1Line (Match.UsrCod,false);
fprintf (Gbl.F.Out,"</td>");
/***** Start date/time *****/
fprintf (Gbl.F.Out,"<td id=\"mch_date_start_%u\""
" class=\"%s LEFT_TOP COLOR%u\">",
UniqueId,
Match.Status.QstInd >= Mch_AFTER_LAST_QUESTION ? "DATE_RED" :
"DATE_GREEN",
Gbl.RowEvenOdd);
fprintf (Gbl.F.Out,"<script type=\"text/javascript\">"
"writeLocalDateHMSFromUTC('mch_date_start_%u',%ld,"
"%u,'<br />','%s',true,true,0x7);"
"</script>"
"</td>",
UniqueId,Match.TimeUTC[Gam_START_TIME],
(unsigned) Gbl.Prefs.DateFormat,Txt_Today);
/***** End date/time *****/
fprintf (Gbl.F.Out,"<td id=\"mch_date_end_%u\""
" class=\"%s LEFT_TOP COLOR%u\">",
UniqueId,
Match.Status.QstInd >= Mch_AFTER_LAST_QUESTION ? "DATE_RED" :
"DATE_GREEN",
Gbl.RowEvenOdd);
fprintf (Gbl.F.Out,"\">"
"<script type=\"text/javascript\">"
"writeLocalDateHMSFromUTC('mch_date_end_%u',%ld,"
"%u,'<br />','%s',false,true,0x7);"
"</script>"
"</td>",
UniqueId,Match.TimeUTC[Gam_END_TIME],
(unsigned) Gbl.Prefs.DateFormat,Txt_Today);
/***** Title and groups *****/
fprintf (Gbl.F.Out,"<td class=\"LEFT_TOP COLOR%u\">",Gbl.RowEvenOdd);
/* Title */
fprintf (Gbl.F.Out,"<span class=\"ASG_TITLE\">%s</span>",Match.Title);
/* Groups whose students can answer this match */
if (Gbl.Crs.Grps.NumGrps)
Mch_GetAndWriteNamesOfGrpsAssociatedToMatch (&Match);
fprintf (Gbl.F.Out,"</td>");
/***** Match status ******/
fprintf (Gbl.F.Out,"<td class=\"DAT RIGHT_TOP COLOR%u\">",Gbl.RowEvenOdd);
if (Match.Status.QstInd < Mch_AFTER_LAST_QUESTION) // Unfinished match
/* Current question index / total of questions */
fprintf (Gbl.F.Out,"<div class=\"DAT\">%u/%u</div>",
Match.Status.QstInd,Game->NumQsts);
switch (Gbl.Usrs.Me.Role.Logged)
{
case Rol_STD:
/* Icon to play as student */
Mch_CurrentMchCod = Match.MchCod;
Lay_PutContextualLinkOnlyIcon (ActPlyMchStd,NULL,
Mch_PutParamCurrentMchCod,
Match.Status.QstInd < Mch_AFTER_LAST_QUESTION ? "play.svg" :
"flag-checkered.svg",
Txt_Play);
break;
case Rol_NET:
case Rol_TCH:
case Rol_DEG_ADM:
case Rol_CTR_ADM:
case Rol_INS_ADM:
case Rol_SYS_ADM:
/* Icon to resume */
Mch_CurrentMchCod = Match.MchCod;
Lay_PutContextualLinkOnlyIcon (ActResMchTch,NULL,
Mch_PutParamCurrentMchCod,
Match.Status.QstInd < Mch_AFTER_LAST_QUESTION ? "play.svg" :
"flag-checkered.svg",
Txt_Resume);
break;
default:
break;
}
fprintf (Gbl.F.Out,"</td>");
fprintf (Gbl.F.Out,"</tr>");
}
/***** End table *****/
Tbl_EndTable ();
}
/*****************************************************************************/
/************* Get and write the names of the groups of a match **************/
/*****************************************************************************/
static void Mch_GetAndWriteNamesOfGrpsAssociatedToMatch (struct Match *Match)
{
extern const char *Txt_Group;
extern const char *Txt_Groups;
extern const char *Txt_and;
extern const char *Txt_The_whole_course;
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned long NumRow;
unsigned long NumRows;
/***** Get groups associated to a match from database *****/
NumRows = DB_QuerySELECT (&mysql_res,"can not get groups of a match",
"SELECT crs_grp_types.GrpTypName,crs_grp.GrpName"
Version19.4
2019-09-17 01:37:07 +02:00
" FROM mch_groups,crs_grp,crs_grp_types"
" WHERE mch_groups.MchCod=%ld"
" AND mch_groups.GrpCod=crs_grp.GrpCod"
Version19.1
2019-09-14 12:59:34 +02:00
" AND crs_grp.GrpTypCod=crs_grp_types.GrpTypCod"
" ORDER BY crs_grp_types.GrpTypName,crs_grp.GrpName",
Match->MchCod);
/***** Write heading *****/
fprintf (Gbl.F.Out,"<div class=\"ASG_GRP\">%s: ",
NumRows == 1 ? Txt_Group :
Txt_Groups);
/***** Write groups *****/
if (NumRows) // Groups found...
{
/* Get and write the group types and names */
for (NumRow = 0;
NumRow < NumRows;
NumRow++)
{
/* Get next group */
row = mysql_fetch_row (mysql_res);
/* Write group type name and group name */
fprintf (Gbl.F.Out,"%s %s",row[0],row[1]);
if (NumRows >= 2)
{
if (NumRow == NumRows-2)
fprintf (Gbl.F.Out," %s ",Txt_and);
if (NumRows >= 3)
if (NumRow < NumRows-2)
fprintf (Gbl.F.Out,", ");
}
}
}
else
fprintf (Gbl.F.Out,"%s %s",
Txt_The_whole_course,Gbl.Hierarchy.Crs.ShrtName);
fprintf (Gbl.F.Out,"</div>");
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/******************** Get game data from a database row **********************/
/*****************************************************************************/
static void Mch_GetMatchDataFromRow (MYSQL_RES *mysql_res,
struct Match *Match)
{
MYSQL_ROW row;
/***** Get match data *****/
row = mysql_fetch_row (mysql_res);
/*
Version19.2
2019-09-14 19:46:26 +02:00
row[ 0] MchCod
row[ 1] GamCod
row[ 2] UsrCod
row[ 3] UNIX_TIMESTAMP(StartTime)
row[ 4] UNIX_TIMESTAMP(EndTime)
row[ 5] Title
Version19.1
2019-09-14 12:59:34 +02:00
*/
/***** Get match data *****/
/* Code of the match (row[0]) */
if ((Match->MchCod = Str_ConvertStrCodToLongCod (row[0])) <= 0)
Lay_ShowErrorAndExit ("Wrong code of match.");
/* Code of the game (row[1]) */
if ((Match->GamCod = Str_ConvertStrCodToLongCod (row[1])) <= 0)
Lay_ShowErrorAndExit ("Wrong code of game.");
/* Get match teacher (row[2]) */
Match->UsrCod = Str_ConvertStrCodToLongCod (row[2]);
/* Get start date (row[3] holds the start UTC time) */
Match->TimeUTC[Gam_START_TIME] = Dat_GetUNIXTimeFromStr (row[3]);
/* Get end date (row[4] holds the end UTC time) */
Match->TimeUTC[Gam_END_TIME ] = Dat_GetUNIXTimeFromStr (row[4]);
/* Get the title of the game (row[5]) */
if (row[5])
Str_Copy (Match->Title,row[5],
Gam_MAX_BYTES_TITLE);
else
Match->Title[0] = '\0';
/***** Get current match status *****/
/*
Version19.2
2019-09-14 19:46:26 +02:00
row[ 6] QstInd
row[ 7] QstCod
row[ 8] UNIX_TIMESTAMP(QstStartTime)
row[ 9] ShowResults
row[10] Showing
Version19.1
2019-09-14 12:59:34 +02:00
*/
/* Current question index (row[6]) */
Match->Status.QstInd = Gam_GetQstIndFromStr (row[6]);
/* Current question code (row[7]) */
Match->Status.QstCod = Str_ConvertStrCodToLongCod (row[7]);
/* Get question start date (row[8] holds the start UTC time) */
Match->Status.QstStartTimeUTC = Dat_GetUNIXTimeFromStr (row[8]);
Version19.2
2019-09-14 19:46:26 +02:00
/* Get whether to show results or not (row(9)) */
Match->Status.ShowResults = (row[9][0] == 'Y');
/* Get what to show (stem, answers, results) (row(10)) */
Match->Status.Showing = Mch_GetShowingFromStr (row[10]);
Version19.1
2019-09-14 12:59:34 +02:00
/***** Get whether the match is being played or not *****/
if (Match->Status.QstInd >= Mch_AFTER_LAST_QUESTION) // Finished
Match->Status.BeingPlayed = false;
else // Unfinished
Match->Status.BeingPlayed = Mch_GetIfMatchIsBeingPlayed (Match->MchCod);
}
/*****************************************************************************/
/****************** Get parameter with what is being shown *******************/
/*****************************************************************************/
static Mch_Showing_t Mch_GetShowingFromStr (const char *Str)
{
Mch_Showing_t Showing;
for (Showing = (Mch_Showing_t) 0;
Showing <= (Mch_Showing_t) (Mch_NUM_SHOWING - 1);
Showing++)
if (!strcmp (Str,Mch_ShowingStringsDB[Showing]))
return Showing;
return (Mch_Showing_t) Mch_SHOWING_DEFAULT;
}
/*****************************************************************************/
/************** Request the removal of a match (game instance) ***************/
/*****************************************************************************/
void Mch_RequestRemoveMatchTch (void)
{
extern const char *Txt_Do_you_really_want_to_remove_the_match_X;
extern const char *Txt_Remove_match;
struct Match Match;
/***** Get parameters *****/
/* Get match code */
if ((Match.MchCod = Mch_GetParamMatchCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of match is missing.");
/***** Get data of the match from database *****/
Mch_GetDataOfMatchByCod (&Match);
/***** Show question and button to remove question *****/
Mch_CurrentMchCod = Match.MchCod;
Ale_ShowAlertAndButton (ActRemMchTch,NULL,NULL,Mch_PutParamCurrentMchCod,
Btn_REMOVE_BUTTON,Txt_Remove_match,
Ale_QUESTION,Txt_Do_you_really_want_to_remove_the_match_X,
Match.Title);
/***** Show current game *****/
Gam_ShowOneGame (Match.GamCod,
true, // Show only this game
false, // Do not list game questions
false); // Do not put form to start new match
}
/*****************************************************************************/
/********************** Remove a match (game instance) ***********************/
/*****************************************************************************/
void Mch_RemoveMatchTch (void)
{
extern const char *Txt_Match_X_removed;
struct Match Match;
/***** Get parameters *****/
/* Get match code */
if ((Match.MchCod = Mch_GetParamMatchCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of match is missing.");
/***** Get data of the match from database *****/
Mch_GetDataOfMatchByCod (&Match);
/***** Remove the match from all the tables *****/
/* Remove match players */
DB_QueryDELETE ("can not remove match players",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_players"
" USING mch_players,mch_matches,gam_games"
" WHERE mch_players.MchCod=%ld"
" AND mch_players.MchCod=mch_matches.MchCod"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match.MchCod,Gbl.Hierarchy.Crs.CrsCod);
/* Remove match from list of matches being played */
DB_QueryDELETE ("can not remove match from matches being played",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_playing"
" USING mch_playing,mch_matches,gam_games"
" WHERE mch_playing.MchCod=%ld"
" AND mch_playing.MchCod=mch_matches.MchCod"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match.MchCod,Gbl.Hierarchy.Crs.CrsCod);
/* Remove students' answers to match */
DB_QueryDELETE ("can not remove students' answers associated to a match",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_answers"
" USING mch_answers,mch_matches,gam_games"
" WHERE mch_answers.MchCod=%ld"
" AND mch_answers.MchCod=mch_matches.MchCod"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match.MchCod,Gbl.Hierarchy.Crs.CrsCod);
/* Remove groups associated to the match */
DB_QueryDELETE ("can not remove the groups associated to a match",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_groups"
" USING mch_groups,mch_matches,gam_games"
" WHERE mch_groups.MchCod=%ld"
" AND mch_groups.MchCod=mch_matches.MchCod"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match.MchCod,Gbl.Hierarchy.Crs.CrsCod);
/* Remove the match itself */
DB_QueryDELETE ("can not remove a match",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_matches"
" USING mch_matches,gam_games"
" WHERE mch_matches.MchCod=%ld"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match.MchCod,Gbl.Hierarchy.Crs.CrsCod);
if (!mysql_affected_rows (&Gbl.mysql))
Lay_ShowErrorAndExit ("The match to be removed does not exist.");
/***** Write message *****/
Ale_ShowAlert (Ale_SUCCESS,Txt_Match_X_removed,
Match.Title);
/***** Show current game *****/
Gam_ShowOneGame (Match.GamCod,
true, // Show only this game
false, // Do not list game questions
false); // Do not put form to start new match
}
/*****************************************************************************/
/***************** Put parameter with current match code *********************/
/*****************************************************************************/
static void Mch_PutParamCurrentMchCod (void)
{
if (Mch_CurrentMchCod > 0)
Mch_PutParamMatchCod (Mch_CurrentMchCod);
}
/*****************************************************************************/
/******************** Write parameter with code of match **********************/
/*****************************************************************************/
static void Mch_PutParamMatchCod (long MchCod)
{
Par_PutHiddenParamLong ("MchCod",MchCod);
}
/*****************************************************************************/
/********************* Get parameter with code of match **********************/
/*****************************************************************************/
static long Mch_GetParamMatchCod (void)
{
/***** Get code of match *****/
return Par_GetParToLong ("MchCod");
}
/*****************************************************************************/
/********************* Put button to create a new match **********************/
/*****************************************************************************/
static void Mch_PutButtonNewMatch (long GamCod)
{
extern const char *Txt_New_match;
Frm_StartFormAnchor (ActReqNewMchTch,Mch_NEW_MATCH_SECTION_ID);
Gam_PutParamGameCod (GamCod);
Btn_PutConfirmButton (Txt_New_match);
Frm_EndForm ();
}
/*****************************************************************************/
/****** Put a big button to play match (start a new match) as a teacher ******/
/*****************************************************************************/
static void Mch_PutFormNewMatch (struct Game *Game)
{
extern const char *Hlp_ASSESSMENT_Games_new_match;
extern const char *The_ClassFormInBox[The_NUM_THEMES];
extern const char *Txt_New_match;
extern const char *Txt_Title;
extern const char *Txt_Play;
/***** Start section for a new match *****/
Lay_StartSection (Mch_NEW_MATCH_SECTION_ID);
/***** Start form *****/
Frm_StartForm (ActNewMchTch);
Gam_PutParamGameCod (Game->GamCod);
Gam_PutParamQstInd (0); // Start by first question in game
/***** Start box and table *****/
Box_StartBoxTable (NULL,Txt_New_match,NULL,
Hlp_ASSESSMENT_Games_new_match,Box_NOT_CLOSABLE,2);
/***** Match title *****/
fprintf (Gbl.F.Out,"<tr>"
"<td class=\"RIGHT_MIDDLE\">"
"<label for=\"Title\" class=\"%s\">%s:</label>"
"</td>"
"<td class=\"LEFT_MIDDLE\">"
"<input type=\"text\" id=\"Title\" name=\"Title\""
" size=\"45\" maxlength=\"%u\" value=\"%s\""
" required=\"required\" />"
"</td>"
"</tr>",
The_ClassFormInBox[Gbl.Prefs.Theme],
Txt_Title,
Gam_MAX_CHARS_TITLE,Game->Title);
/***** Groups *****/
Mch_ShowLstGrpsToCreateMatch ();
/***** End table *****/
Tbl_EndTable ();
/***** Put icon with link *****/
Frm_LinkFormSubmit (Txt_Play,NULL,NULL);
fprintf (Gbl.F.Out,"<img src=\"%s/play.svg\""
" alt=\"%s\" title=\"%s\""
" class=\"CONTEXT_OPT ICO_HIGHLIGHT ICO64x64\" />",
Cfg_URL_ICON_PUBLIC,Txt_Play,Txt_Play);
fprintf (Gbl.F.Out,"</a>");
/***** End box *****/
Box_EndBox ();
/***** End form *****/
Frm_EndForm ();
/***** End section for a new match *****/
Lay_EndSection ();
}
/*****************************************************************************/
/***************** Show list of groups to create a new match *****************/
/*****************************************************************************/
static void Mch_ShowLstGrpsToCreateMatch (void)
{
extern const char *The_ClassFormInBox[The_NUM_THEMES];
extern const char *Txt_Groups;
extern const char *Txt_The_whole_course;
unsigned NumGrpTyp;
/***** Get list of groups types and groups in this course *****/
Grp_GetListGrpTypesAndGrpsInThisCrs (Grp_ONLY_GROUP_TYPES_WITH_GROUPS);
if (Gbl.Crs.Grps.GrpTypes.Num)
{
/***** Start box and table *****/
fprintf (Gbl.F.Out,"<tr>"
"<td class=\"%s RIGHT_TOP\">"
"%s:"
"</td>"
"<td class=\"LEFT_TOP\">",
The_ClassFormInBox[Gbl.Prefs.Theme],
Txt_Groups);
Box_StartBoxTable ("95%",NULL,NULL,
NULL,Box_NOT_CLOSABLE,0);
/***** First row: checkbox to select the whole course *****/
fprintf (Gbl.F.Out,"<tr>"
"<td colspan=\"7\" class=\"DAT LEFT_MIDDLE\">"
"<label>"
"<input type=\"checkbox\""
" id=\"WholeCrs\" name=\"WholeCrs\" value=\"Y\""
" checked=\"checked\""
" onclick=\"uncheckChildren(this,'GrpCods')\" />"
"%s %s"
"</label>"
"</td>"
"</tr>",
Txt_The_whole_course,Gbl.Hierarchy.Crs.ShrtName);
/***** List the groups for each group type *****/
for (NumGrpTyp = 0;
NumGrpTyp < Gbl.Crs.Grps.GrpTypes.Num;
NumGrpTyp++)
if (Gbl.Crs.Grps.GrpTypes.LstGrpTypes[NumGrpTyp].NumGrps)
Grp_ListGrpsToEditAsgAttSvyMch (&Gbl.Crs.Grps.GrpTypes.LstGrpTypes[NumGrpTyp],
-1L, // -1 means "New match"
Grp_MATCH);
/***** End table and box *****/
Box_EndBoxTable ();
fprintf (Gbl.F.Out,"</td>"
"</tr>");
}
/***** Free list of groups types and groups in this course *****/
Grp_FreeListGrpTypesAndGrps ();
}
/*****************************************************************************/
/********************* Create a new match (by a teacher) *********************/
/*****************************************************************************/
void Mch_CreateNewMatchTch (void)
{
long GamCod;
char Title[Gam_MAX_BYTES_TITLE + 1];
/***** Get form parameters *****/
/* Get match code */
if ((GamCod = Gam_GetParamGameCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of game is missing.");
/* Get match title */
Par_GetParToText ("Title",Title,Gam_MAX_BYTES_TITLE);
/* Get groups for this games */
Grp_GetParCodsSeveralGrps ();
/***** Create a new match *****/
Gbl.Games.MchCodBeingPlayed = Mch_CreateMatch (GamCod,Title);
/***** Free memory for list of selected groups *****/
Grp_FreeListCodSelectedGrps ();
}
/*****************************************************************************/
/******* Show button to actually start / resume a match (by a teacher) *******/
/*****************************************************************************/
void Mch_RequestStartResumeMatchTch (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/********************** Create a new match in a game *************************/
/*****************************************************************************/
static long Mch_CreateMatch (long GamCod,char Title[Gam_MAX_BYTES_TITLE + 1])
{
long MchCod;
/***** Insert this new match into database *****/
MchCod = DB_QueryINSERTandReturnCode ("can not create match",
Version19.4
2019-09-17 01:37:07 +02:00
"INSERT mch_matches"
Version19.1
2019-09-14 12:59:34 +02:00
" (GamCod,UsrCod,StartTime,EndTime,Title,ShowResults,"
"QstInd,QstCod,QstStartTime,Showing)"
" VALUES"
" (%ld," // GamCod
"%ld," // UsrCod
"NOW()," // StartTime
"NOW()," // EndTime
"'%s'," // Title
"'N'," // ShowResults: Don't show results initially
"0," // QstInd: Match has not started, so not the first question yet
"-1," // QstCod: Non-existent question
"NOW()," // QstStartTime
"'%s'", // What is being shown
GamCod,
Gbl.Usrs.Me.UsrDat.UsrCod, // Game creator
Title,
Mch_ShowingStringsDB[Mch_SHOWING_DEFAULT]);
/***** Create groups associated to the match *****/
if (Gbl.Crs.Grps.LstGrpsSel.NumGrps)
Mch_CreateGrps (MchCod);
return MchCod;
}
/*****************************************************************************/
/******************* Create groups associated to a match *********************/
/*****************************************************************************/
static void Mch_CreateGrps (long MchCod)
{
unsigned NumGrpSel;
/***** Create groups associated to the match *****/
for (NumGrpSel = 0;
NumGrpSel < Gbl.Crs.Grps.LstGrpsSel.NumGrps;
NumGrpSel++)
/* Create group */
DB_QueryINSERT ("can not associate a group to a match",
Version19.4
2019-09-17 01:37:07 +02:00
"INSERT INTO mch_groups"
Version19.1
2019-09-14 12:59:34 +02:00
" (MchCod,GrpCod)"
" VALUES"
" (%ld,%ld)",
MchCod,Gbl.Crs.Grps.LstGrpsSel.GrpCods[NumGrpSel]);
}
/*****************************************************************************/
/***************** Insert/update a game match being played *******************/
/*****************************************************************************/
static void Mch_UpdateMatchStatusInDB (struct Match *Match)
{
/***** Update match status in database *****/
DB_QueryUPDATE ("can not update match being played",
Version19.4
2019-09-17 01:37:07 +02:00
"UPDATE mch_matches,gam_games"
" SET mch_matches.EndTime=NOW(),"
"mch_matches.QstInd=%u,"
"mch_matches.QstCod=%ld,"
"mch_matches.QstStartTime=NOW(),"
"mch_matches.ShowResults='%c',"
"mch_matches.Showing='%s'"
" WHERE mch_matches.MchCod=%ld"
" AND mch_matches.GamCod=gam_games.GamCod"
" AND gam_games.CrsCod=%ld", // Extra check
Version19.1
2019-09-14 12:59:34 +02:00
Match->Status.QstInd,Match->Status.QstCod,
Version19.2
2019-09-14 19:46:26 +02:00
Match->Status.ShowResults ? 'Y' : 'N',
Version19.1
2019-09-14 12:59:34 +02:00
Mch_ShowingStringsDB[Match->Status.Showing],
Match->MchCod,Gbl.Hierarchy.Crs.CrsCod);
if (Match->Status.BeingPlayed)
/* Update match as being played */
Mch_UpdateMatchAsBeingPlayed (Match->MchCod);
else
/* Update match as not being played */
Mch_SetMatchAsNotBeingPlayed (Match->MchCod);
}
/*****************************************************************************/
/********** Update elapsed time in current question (by a teacher) ***********/
/*****************************************************************************/
static void Mch_UpdateElapsedTimeInQuestion (struct Match *Match)
{
/***** Update elapsed time in current question in database *****/
if (Match->Status.BeingPlayed &&
Match->Status.QstInd > 0 &&
Match->Status.QstInd < Mch_AFTER_LAST_QUESTION)
DB_QueryINSERT ("can not update elapsed time in question",
Version19.4
2019-09-17 01:37:07 +02:00
"INSERT INTO mch_times (MchCod,QstInd,ElapsedTime)"
Version19.1
2019-09-14 12:59:34 +02:00
" VALUES (%ld,%u,SEC_TO_TIME(%u))"
" ON DUPLICATE KEY"
" UPDATE ElapsedTime=ADDTIME(ElapsedTime,SEC_TO_TIME(%u))",
Match->MchCod,Match->Status.QstInd,
Cfg_SECONDS_TO_REFRESH_GAME,
Cfg_SECONDS_TO_REFRESH_GAME);
}
/*****************************************************************************/
/******************* Get elapsed time in a match question ********************/
/*****************************************************************************/
static void Mch_GetElapsedTimeInQuestion (struct Match *Match,
struct Time *Time)
{
MYSQL_RES *mysql_res;
unsigned NumRows;
/***** Query database *****/
NumRows = (unsigned) DB_QuerySELECT (&mysql_res,"can not get elapsed time",
"SELECT ElapsedTime"
Version19.4
2019-09-17 01:37:07 +02:00
" FROM mch_times"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld AND QstInd=%u",
Match->MchCod,Match->Status.QstInd);
/***** Get elapsed time from query result *****/
Mch_GetElapsedTime (NumRows,mysql_res,Time);
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/*********************** Get elapsed time in a match *************************/
/*****************************************************************************/
static void Mch_GetElapsedTimeInMatch (struct Match *Match,
struct Time *Time)
{
MYSQL_RES *mysql_res;
unsigned NumRows;
/***** Query database *****/
NumRows = (unsigned) DB_QuerySELECT (&mysql_res,"can not get elapsed time",
"SELECT SEC_TO_TIME(SUM(TIME_TO_SEC(ElapsedTime)))"
Version19.4
2019-09-17 01:37:07 +02:00
" FROM mch_times WHERE MchCod=%ld",
Version19.1
2019-09-14 12:59:34 +02:00
Match->MchCod);
/***** Get elapsed time from query result *****/
Mch_GetElapsedTime (NumRows,mysql_res,Time);
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
}
/*****************************************************************************/
/*********************** Get elapsed time in a match *************************/
/*****************************************************************************/
static void Mch_GetElapsedTime (unsigned NumRows,MYSQL_RES *mysql_res,
struct Time *Time)
{
MYSQL_ROW row;
bool ElapsedTimeGotFromDB = false;
/***** Get time from H...H:MM:SS string *****/
if (NumRows)
{
row = mysql_fetch_row (mysql_res);
if (row[0])
/* Get the elapsed time (row[0]) */
if (sscanf (row[0],"%u:%02u:%02u",&Time->Hour,&Time->Minute,&Time->Second) == 3)
ElapsedTimeGotFromDB = true;
}
/***** Initialize time to default value (0) *****/
if (!ElapsedTimeGotFromDB)
Time->Hour =
Time->Minute =
Time->Second = 0;
}
/*****************************************************************************/
/********************* Pause current match (by a teacher) ********************/
/*****************************************************************************/
void Mch_PauseMatchTch (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update status *****/
Match.Status.BeingPlayed = false; // Resume match
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/** Show current match status (current question, answers...) (by a teacher) **/
/*****************************************************************************/
void Mch_ResumeMatchTch (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** If not yet finished, update status *****/
if (Match.Status.QstInd < Mch_AFTER_LAST_QUESTION) // Unfinished
{
if (Match.Status.QstInd == 0) // Match has been created, but it has not started
Mch_SetMatchStatusToNext (&Match);
Match.Status.BeingPlayed = true; // Start/resume match
}
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
Version19.2
2019-09-14 19:46:26 +02:00
/********* Toggle the display of results in a match (by a teacher) ***********/
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
Version19.2
2019-09-14 19:46:26 +02:00
void Mch_ToggleDisplayResultsMatchTch (void)
Version19.1
2019-09-14 12:59:34 +02:00
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update status *****/
Version19.2
2019-09-14 19:46:26 +02:00
Match.Status.ShowResults = !Match.Status.ShowResults; // Toggle display
if (!Match.Status.ShowResults &&
Match.Status.Showing == Mch_RESULTS)
Match.Status.Showing = Mch_ANSWERS; // Hide results
Version19.1
2019-09-14 12:59:34 +02:00
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/************* Show previous question in a match (by a teacher) **************/
/*****************************************************************************/
void Mch_BackMatchTch (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update status *****/
Mch_SetMatchStatusToPrev (&Match);
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/*************** Show next question in a match (by a teacher) ****************/
/*****************************************************************************/
void Mch_ForwardMatchTch (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update status *****/
Mch_SetMatchStatusToNext (&Match);
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForTch (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/************** Set match status to previous (backward) status ***************/
/*****************************************************************************/
static void Mch_SetMatchStatusToPrev (struct Match *Match)
{
/***** What to show *****/
switch (Match->Status.Showing)
{
Version19.3
2019-09-16 00:15:40 +02:00
case Mch_STEM:
Version19.2
2019-09-14 19:46:26 +02:00
Match->Status.Showing = Match->Status.ShowResults ? Mch_RESULTS :
Mch_ANSWERS;
Version19.1
2019-09-14 12:59:34 +02:00
/***** Get index of the previous question *****/
Match->Status.QstInd = Gam_GetPrevQuestionIndexInGame (Match->GamCod,
Match->Status.QstInd);
if (Match->Status.QstInd == 0) // Start of questions has been reached
{
Match->Status.QstCod = -1L; // No previous questions
Match->Status.BeingPlayed = false; // Match is not being played
}
else
Match->Status.QstCod = Gam_GetQstCodFromQstInd (Match->GamCod,
Match->Status.QstInd);
break;
case Mch_ANSWERS:
Version19.3
2019-09-16 00:15:40 +02:00
Match->Status.Showing = Mch_STEM;
Version19.1
2019-09-14 12:59:34 +02:00
break;
case Mch_RESULTS:
Version19.2
2019-09-14 19:46:26 +02:00
Match->Status.Showing = Mch_ANSWERS;
Version19.1
2019-09-14 12:59:34 +02:00
break;
}
}
/*****************************************************************************/
/**************** Set match status to next (forward) status ******************/
/*****************************************************************************/
static void Mch_SetMatchStatusToNext (struct Match *Match)
{
/***** What to show *****/
switch (Match->Status.Showing)
{
Version19.3
2019-09-16 00:15:40 +02:00
case Mch_STEM:
Version19.1
2019-09-14 12:59:34 +02:00
Match->Status.Showing = Mch_ANSWERS;
break;
case Mch_ANSWERS:
Version19.2
2019-09-14 19:46:26 +02:00
Match->Status.Showing = Match->Status.ShowResults ? Mch_RESULTS :
Version19.3
2019-09-16 00:15:40 +02:00
Mch_STEM;
Version19.1
2019-09-14 12:59:34 +02:00
break;
case Mch_RESULTS:
Version19.3
2019-09-16 00:15:40 +02:00
Match->Status.Showing = Mch_STEM;
Version19.1
2019-09-14 12:59:34 +02:00
break;
}
Version19.2
2019-09-14 19:46:26 +02:00
/***** Go to next question? *****/
Version19.3
2019-09-16 00:15:40 +02:00
if (Match->Status.Showing == Mch_STEM)
Version19.2
2019-09-14 19:46:26 +02:00
{
/***** Get index of the next question *****/
Match->Status.QstInd = Gam_GetNextQuestionIndexInGame (Match->GamCod,
Match->Status.QstInd);
if (Match->Status.QstInd < Mch_AFTER_LAST_QUESTION) // Unfinished
Match->Status.QstCod = Gam_GetQstCodFromQstInd (Match->GamCod,
Match->Status.QstInd);
else // Finished
{
Match->Status.QstCod = -1L; // No more questions
Match->Status.BeingPlayed = false;
}
}
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
/******* Show current match status (number, question, answers, button) *******/
/*****************************************************************************/
static void Mch_ShowMatchStatusForTch (struct Match *Match)
{
/***** Get current number of players *****/
Mch_GetNumPlayers (Match);
/***** Left column *****/
Mch_ShowLeftColumnTch (Match);
/***** Right column *****/
/* Start right container */
fprintf (Gbl.F.Out,"<div class=\"MATCH_RIGHT\">");
/* Top row: match title */
Mch_ShowMatchTitle (Match);
/* Bottom row: current question and possible answers */
Mch_ShowQuestionAndAnswersTch (Match);
/* End right container */
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/************ Show current question being played for a student ***************/
/*****************************************************************************/
static void Mch_ShowMatchStatusForStd (struct Match *Match)
{
extern const char *Txt_Please_wait_;
bool IBelongToGroups;
/***** Do I belong to valid groups to play this match? *****/
IBelongToGroups = Gbl.Usrs.Me.IBelongToCurrentCrs &&
Mch_CheckIfIPlayThisMatchBasedOnGrps (Match->MchCod);
if (!IBelongToGroups)
Lay_ShowErrorAndExit ("You can not play this match!");
/***** Get current number of players *****/
Mch_GetNumPlayers (Match);
/***** Left column *****/
Mch_ShowLeftColumnStd (Match);
/***** Right column *****/
/* Start right container */
fprintf (Gbl.F.Out,"<div class=\"MATCH_RIGHT\">");
/***** Top row *****/
Mch_ShowMatchTitle (Match);
/***** Bottom row *****/
if (Match->Status.QstInd < Mch_AFTER_LAST_QUESTION) // Unfinished
{
fprintf (Gbl.F.Out,"<div class=\"MATCH_BOTTOM\">");
/***** Update players ******/
Mch_RegisterMeAsPlayerInMatch (Match->MchCod);
if (Match->Status.BeingPlayed)
/* Show current question and possible answers */
Mch_ShowQuestionAndAnswersStd (Match);
else // Not being played
Mch_ShowWaitImage (Txt_Please_wait_);
fprintf (Gbl.F.Out,"</div>");
}
/* End right container */
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/************ Check if I belong to any of the groups of a match **************/
/*****************************************************************************/
static bool Mch_CheckIfIPlayThisMatchBasedOnGrps (long MchCod)
{
/***** Get if I can play a match from database *****/
return (DB_QueryCOUNT ("can not check if I can play a match",
Version19.4
2019-09-17 01:37:07 +02:00
"SELECT COUNT(*) FROM mch_matches"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld"
Version19.4
2019-09-17 01:37:07 +02:00
" AND (MchCod NOT IN (SELECT MchCod FROM mch_groups) OR"
" MchCod IN (SELECT mch_groups.MchCod FROM mch_groups,crs_grp_usr"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE crs_grp_usr.UsrCod=%ld"
Version19.4
2019-09-17 01:37:07 +02:00
" AND mch_groups.GrpCod=crs_grp_usr.GrpCod))",
Version19.1
2019-09-14 12:59:34 +02:00
MchCod,Gbl.Usrs.Me.UsrDat.UsrCod) != 0);
}
/*****************************************************************************/
/******** Show left botton column when playing a match (as a teacher) ********/
/*****************************************************************************/
static void Mch_ShowLeftColumnTch (struct Match *Match)
{
extern const char *Txt_MATCH_respond;
struct Time Time;
Version19.3
2019-09-16 00:15:40 +02:00
unsigned NumAnswerersQst;
Version19.1
2019-09-14 12:59:34 +02:00
/***** Start left container *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_LEFT\">");
/***** Top *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_TOP\">");
/* Write elapsed time in match */
Mch_GetElapsedTimeInMatch (Match,&Time);
Dat_WriteHoursMinutesSeconds (&Time);
fprintf (Gbl.F.Out,"</div>");
/***** Write number of question *****/
Mch_ShowNumQstInMatch (Match);
/***** Write elapsed time in question *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_TIME_QST\">");
if (Match->Status.QstInd > 0 &&
Match->Status.QstInd < Mch_AFTER_LAST_QUESTION)
{
Mch_GetElapsedTimeInQuestion (Match,&Time);
Dat_WriteHoursMinutesSeconds (&Time);
}
else
fprintf (Gbl.F.Out,"-");
fprintf (Gbl.F.Out,"</div>");
/***** Buttons *****/
Mch_PutMatchControlButtons (Match);
Version19.2
2019-09-14 19:46:26 +02:00
/***** Write button to request viewing results *****/
Mch_PutCheckboxResult (Match);
Version19.1
2019-09-14 12:59:34 +02:00
/***** Number of players *****/
Mch_ShowNumPlayers (Match);
Version19.3
2019-09-16 00:15:40 +02:00
/***** Number of users who have answered this question *****/
Version19.1
2019-09-14 12:59:34 +02:00
if (Match->Status.BeingPlayed)
{
Version19.3
2019-09-16 00:15:40 +02:00
NumAnswerersQst = Mch_GetNumUsrsWhoHaveAnswerQst (Match->MchCod,
Match->Status.QstInd);
Version19.1
2019-09-14 12:59:34 +02:00
fprintf (Gbl.F.Out,"<div class=\"MATCH_NUM_ANSWERERS\">"
"%s<br />"
"<strong>%u/%u</strong>"
"</div>",
Txt_MATCH_respond,
Version19.3
2019-09-16 00:15:40 +02:00
NumAnswerersQst,Match->Status.NumPlayers);
Version19.1
2019-09-14 12:59:34 +02:00
}
/***** End left container *****/
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/******** Show left botton column when playing a match (as a student) ********/
/*****************************************************************************/
static void Mch_ShowLeftColumnStd (struct Match *Match)
{
/***** Start left container *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_LEFT\">");
/***** Top *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_TOP\"></div>");
/***** Write number of question *****/
Mch_ShowNumQstInMatch (Match);
/***** End left container *****/
fprintf (Gbl.F.Out,"</div>");
}
Version19.2
2019-09-14 19:46:26 +02:00
/*****************************************************************************/
/********************* Show number of question in game ***********************/
/*****************************************************************************/
static void Mch_ShowNumQstInMatch (struct Match *Match)
{
extern const char *Txt_MATCH_Start;
extern const char *Txt_MATCH_End;
unsigned NumQsts = Gam_GetNumQstsGame (Match->GamCod);
fprintf (Gbl.F.Out,"<div class=\"MATCH_NUM_QST\">");
if (Match->Status.QstInd == 0) // Not started
fprintf (Gbl.F.Out,"%s",Txt_MATCH_Start);
else if (Match->Status.QstInd >= Mch_AFTER_LAST_QUESTION) // Finished
fprintf (Gbl.F.Out,"%s",Txt_MATCH_End);
else
fprintf (Gbl.F.Out,"%u/%u",Match->Status.QstInd,NumQsts);
fprintf (Gbl.F.Out,"</div>");
}
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
/********************** Put buttons to control a match ***********************/
/*****************************************************************************/
static void Mch_PutMatchControlButtons (struct Match *Match)
{
extern const char *Txt_Go_back;
extern const char *Txt_Go_forward;
extern const char *Txt_Pause;
extern const char *Txt_Start;
extern const char *Txt_Resume;
/***** Start buttons container *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTONS_CONTAINER\">");
/***** Left button *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_LEFT_CONTAINER\">");
if (Match->Status.QstInd == 0)
/* Put button to close browser tab */
Mch_PutBigButtonClose ();
else
/* Put button to go back */
Mch_PutBigButton (ActBckMchTch,Match->MchCod,
Mch_ICON_PREVIOUS,Txt_Go_back);
fprintf (Gbl.F.Out,"</div>");
/***** Center button *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_CENTER_CONTAINER\">");
if (Match->Status.BeingPlayed) // Being played
/* Put button to pause match */
Mch_PutBigButton (ActPauMchTch,
Match->MchCod,
Mch_ICON_PAUSE,Txt_Pause);
else // Paused
{
if (Match->Status.QstInd < Mch_AFTER_LAST_QUESTION) // Not finished
/* Put button to play match */
Mch_PutBigButton (ActPlyMchTch,
Match->MchCod,
Mch_ICON_PLAY,Match->Status.QstInd == 0 ? Txt_Start :
Txt_Resume);
else // Finished
/* Put disabled button to play match */
Mch_PutBigButtonOff (Mch_ICON_PLAY);
}
fprintf (Gbl.F.Out,"</div>");
/***** Right button *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_RIGHT_CONTAINER\">");
if (Match->Status.QstInd >= Mch_AFTER_LAST_QUESTION) // Finished
/* Put button to close browser tab */
Mch_PutBigButtonClose ();
else
/* Put button to show answers */
Mch_PutBigButton (ActFwdMchTch,Match->MchCod,
Mch_ICON_NEXT,Txt_Go_forward);
fprintf (Gbl.F.Out,"</div>");
/***** End buttons container *****/
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
Version19.2
2019-09-14 19:46:26 +02:00
/***************** Put checkbox to select if show results ********************/
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
Version19.2
2019-09-14 19:46:26 +02:00
static void Mch_PutCheckboxResult (struct Match *Match)
Version19.1
2019-09-14 12:59:34 +02:00
{
Version19.2
2019-09-14 19:46:26 +02:00
extern const char *Txt_View_results;
Version19.1
2019-09-14 12:59:34 +02:00
Version19.2
2019-09-14 19:46:26 +02:00
/***** Start container *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_SHOW_RESULTS\">");
/***** Start form *****/
Frm_StartForm (ActChgDisResMchTch);
Mch_PutParamMatchCod (Match->MchCod); // Current match being played
/***** Put icon with link *****/
/* Submitting onmousedown instead of default onclick
is necessary in order to be fast
and not lose clicks due to refresh */
fprintf (Gbl.F.Out,"<div class=\"CONTEXT_OPT\">"
"<a href=\"\" class=\"ICO_HIGHLIGHT\""
" title=\"%s\" "
" onmousedown=\"document.getElementById('%s').submit();"
" return false;\">"
"<i class=\"%s\"></i>"
"&nbsp;%s"
"</a>"
"</div>",
Txt_View_results,
Gbl.Form.Id,
Match->Status.ShowResults ? "fas fa-toggle-on" :
"fas fa-toggle-off",
Txt_View_results);
/***** End form *****/
Frm_EndForm ();
/***** End container *****/
Version19.1
2019-09-14 12:59:34 +02:00
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/************************** Show number of players ***************************/
/*****************************************************************************/
static void Mch_ShowNumPlayers (struct Match *Match)
{
extern const char *Txt_Players;
fprintf (Gbl.F.Out,"<div class=\"MATCH_NUM_PLAYERS\">"
"%s<br />"
"<strong>%u</strong>"
"</div>",
Txt_Players,Match->Status.NumPlayers);
}
/*****************************************************************************/
/***************************** Show match title ******************************/
/*****************************************************************************/
static void Mch_ShowMatchTitle (struct Match *Match)
{
/***** Match title *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_TOP\">%s</div>",Match->Title);
}
/*****************************************************************************/
/***** Show question and its answers when playing a match (as a teacher) *****/
/*****************************************************************************/
static void Mch_ShowQuestionAndAnswersTch (struct Match *Match)
{
extern const char *Txt_MATCH_Paused;
extern const char *Txt_View_results;
MYSQL_RES *mysql_res;
MYSQL_ROW row;
/***** Trivial check: question index should be correct *****/
if (Match->Status.QstInd == 0 ||
Match->Status.QstInd >= Mch_AFTER_LAST_QUESTION)
return;
/***** Get data of question from database *****/
if (!DB_QuerySELECT (&mysql_res,"can not get data of a question",
"SELECT AnsType," // row[0]
"Stem," // row[1]
"MedCod" // row[2]
" FROM tst_questions"
" WHERE QstCod=%ld",
Match->Status.QstCod))
Ale_ShowAlert (Ale_ERROR,"Question doesn't exist.");
row = mysql_fetch_row (mysql_res);
/***** Show question *****/
/* Get answer type (row[0]) */
Gbl.Test.AnswerType = Tst_ConvertFromStrAnsTypDBToAnsTyp (row[0]);
// TODO: Check that answer type is correct (unique choice)
Version19.3
2019-09-16 00:15:40 +02:00
fprintf (Gbl.F.Out,"<div class=\"MATCH_BOTTOM\">"); // Bottom
Version19.1
2019-09-14 12:59:34 +02:00
/* Write stem (row[1]) */
Version19.3
2019-09-16 00:15:40 +02:00
Tst_WriteQstStem (row[1],"MATCH_TCH_STEM");
Version19.1
2019-09-14 12:59:34 +02:00
/* Get media (row[2]) */
Gbl.Test.Media.MedCod = Str_ConvertStrCodToLongCod (row[2]);
Med_GetMediaDataByCod (&Gbl.Test.Media);
/* Show media */
Med_ShowMedia (&Gbl.Test.Media,
"TEST_MED_EDIT_LIST_STEM_CONTAINER",
"TEST_MED_EDIT_LIST_STEM");
/* Write answers? */
switch (Match->Status.Showing)
{
Version19.3
2019-09-16 00:15:40 +02:00
case Mch_STEM:
Version19.1
2019-09-14 12:59:34 +02:00
/* Don't write anything */
break;
case Mch_ANSWERS:
Version19.3
2019-09-16 00:15:40 +02:00
if (Match->Status.BeingPlayed) // Being played
Version19.1
2019-09-14 12:59:34 +02:00
/* Write answers */
Tst_WriteAnswersMatchResult (Match->MchCod,
Match->Status.QstInd,
Match->Status.QstCod,
Version19.3
2019-09-16 00:15:40 +02:00
"MATCH_TCH_ANS",
false); // Don't show result
else // Not being played
Version19.1
2019-09-14 12:59:34 +02:00
Mch_ShowWaitImage (Txt_MATCH_Paused);
break;
case Mch_RESULTS:
/* Write answers with results */
Tst_WriteAnswersMatchResult (Match->MchCod,
Match->Status.QstInd,
Match->Status.QstCod,
Version19.3
2019-09-16 00:15:40 +02:00
"MATCH_TCH_ANS",
true); // Show result
Version19.1
2019-09-14 12:59:34 +02:00
break;
}
Version19.3
2019-09-16 00:15:40 +02:00
fprintf (Gbl.F.Out,"</div>"); // Bottom
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
/***** Show question and its answers when playing a match (as a student) *****/
/*****************************************************************************/
static void Mch_ShowQuestionAndAnswersStd (struct Match *Match)
{
bool Shuffle = false; // TODO: Read shuffle from question
MYSQL_RES *mysql_res;
MYSQL_ROW row;
int StdAnsInd;
unsigned NumOptions;
unsigned NumOpt;
unsigned Index;
bool ErrorInIndex = false;
/***** Show question *****/
/* Write buttons for answers? */
if (Match->Status.Showing == Mch_ANSWERS)
{
if (Tst_CheckIfQuestionIsValidForGame (Match->Status.QstCod))
{
/***** Get student's answer to this question
(<0 ==> no answer) *****/
StdAnsInd = Mch_GetQstAnsFromDB (Match->MchCod,
Match->Status.QstInd);
/***** Get number of options in this question *****/
NumOptions = Tst_GetNumAnswersQst (Match->Status.QstCod);
/***** Get answers of question from database *****/
Shuffle = false;
NumOptions = Tst_GetAnswersQst (Match->Status.QstCod,&mysql_res,Shuffle);
/*
row[0] AnsInd
row[1] Answer
row[2] Feedback
row[3] MedCod
row[4] Correct
*/
/***** Start table *****/
Tbl_StartTableWide (8);
for (NumOpt = 0;
NumOpt < NumOptions;
NumOpt++)
{
/***** Get next answer *****/
row = mysql_fetch_row (mysql_res);
/***** Assign index (row[0]).
Index is 0,1,2,3... if no shuffle
or 1,3,0,2... (example) if shuffle *****/
if (sscanf (row[0],"%u",&Index) == 1)
{
if (Index >= Tst_MAX_OPTIONS_PER_QUESTION)
ErrorInIndex = true;
}
else
ErrorInIndex = true;
if (ErrorInIndex)
Lay_ShowErrorAndExit ("Wrong index of answer when showing a test.");
/***** Start row *****/
// if (NumOpt % 2 == 0)
fprintf (Gbl.F.Out,"<tr>");
/***** Write letter for this option *****/
/* Start table cell */
fprintf (Gbl.F.Out,"<td class=\"MATCH_STD_CELL\">");
/* Form with button.
Sumitting onmousedown instead of default onclick
is necessary in order to be fast
and not lose clicks due to refresh */
Frm_StartForm (ActAnsMchQstStd);
Mch_PutParamMatchCod (Match->MchCod); // Current match being played
Gam_PutParamQstInd (Match->Status.QstInd); // Current question index shown
Mch_PutParamAnswer (Index); // Index for this option
fprintf (Gbl.F.Out,"<button type=\"submit\""
" onmousedown=\"document.getElementById('%s').submit();"
"return false;\" class=\"",
Gbl.Form.Id);
if (StdAnsInd == (int) NumOpt) // Student's answer
fprintf (Gbl.F.Out,"MATCH_STD_ANSWER_SELECTED ");
fprintf (Gbl.F.Out,"MATCH_STD_BUTTON BT_%c\">"
"%c"
"</button>",
'A' + (char) NumOpt,
'a' + (char) NumOpt);
Frm_EndForm ();
/* End table cell */
fprintf (Gbl.F.Out,"</td>");
/***** End row *****/
// if (NumOpt % 2 == 1)
fprintf (Gbl.F.Out,"</tr>");
}
/***** End table *****/
Tbl_EndTable ();
}
else
Ale_ShowAlert (Ale_ERROR,"Type of answer not valid in a game.");
}
}
/*****************************************************************************/
/******************* Write parameter with student's answer *******************/
/*****************************************************************************/
static void Mch_PutParamAnswer (unsigned AnsInd)
{
Par_PutHiddenParamUnsigned ("Ans",AnsInd);
}
/*****************************************************************************/
/******************* Get parameter with student's answer *********************/
/*****************************************************************************/
static unsigned Mch_GetParamAnswer (void)
{
long LongNum;
LongNum = Par_GetParToLong ("Ans");
if (LongNum < 0)
Lay_ShowErrorAndExit ("Wrong answer index.");
return (unsigned) LongNum;
}
/*****************************************************************************/
/*********************** Put a big button to do action ***********************/
/*****************************************************************************/
static void Mch_PutBigButton (Act_Action_t NextAction,long MchCod,
const char *Icon,const char *Txt)
{
/***** Start form *****/
Frm_StartForm (NextAction);
Mch_PutParamMatchCod (MchCod);
/***** Put icon with link *****/
/* Submitting onmousedown instead of default onclick
is necessary in order to be fast
and not lose clicks due to refresh */
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_CONTAINER\">"
"<a href=\"\" class=\"MATCH_BUTTON_ON\" title=\"%s\" "
" onmousedown=\"document.getElementById('%s').submit();"
" return false;\">"
"<i class=\"%s\"></i>"
"</a>"
"</div>",
Txt,
Gbl.Form.Id,
Icon);
/***** End form *****/
Frm_EndForm ();
}
static void Mch_PutBigButtonOff (const char *Icon)
{
/***** Put inactive icon *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_CONTAINER\">"
"<div class=\"MATCH_BUTTON_OFF\">"
"<i class=\"%s\"></i>"
"</div>"
"</div>",
Icon);
}
static void Mch_PutBigButtonClose (void)
{
extern const char *Txt_Close;
/***** Put icon with link *****/
/* onmousedown instead of default onclick
is necessary in order to be fast
and not lose clicks due to refresh */
fprintf (Gbl.F.Out,"<div class=\"MATCH_BUTTON_CONTAINER\">"
"<a href=\"\" class=\"MATCH_BUTTON_ON\" title=\"%s\" "
" onmousedown=\"window.close();"
" return false;\"\">"
"<i class=\"%s\"></i>"
"</a>"
"</div>",
Txt_Close,Mch_ICON_CLOSE);
}
/*****************************************************************************/
/****************************** Show wait image ******************************/
/*****************************************************************************/
static void Mch_ShowWaitImage (const char *Txt)
{
fprintf (Gbl.F.Out,"<div class=\"MATCH_WAIT_CONTAINER\">"
"<img src=\"%s/wait.gif\""
" alt=\"%s\" title=\"%s\""
" class=\"MATCH_WAIT_IMAGE\" />"
"</div>",
Cfg_URL_ICON_PUBLIC,
Txt,
Txt);
}
/*****************************************************************************/
/**************************** Remove old players *****************************/
/*****************************************************************************/
static void Mch_RemoveOldPlayers (void)
{
/***** Delete matches not being played *****/
DB_QueryDELETE ("can not update matches as not being played",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_playing"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE TS<FROM_UNIXTIME(UNIX_TIMESTAMP()-%lu)",
Cfg_SECONDS_TO_REFRESH_GAME*3);
/***** Delete players who have left matches *****/
DB_QueryDELETE ("can not update match players",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_players"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE TS<FROM_UNIXTIME(UNIX_TIMESTAMP()-%lu)",
Cfg_SECONDS_TO_REFRESH_GAME*3);
}
static void Mch_UpdateMatchAsBeingPlayed (long MchCod)
{
/***** Insert match as being played *****/
DB_QueryREPLACE ("can not set match as being played",
Version19.4
2019-09-17 01:37:07 +02:00
"REPLACE mch_playing (MchCod) VALUE (%ld)",
Version19.1
2019-09-14 12:59:34 +02:00
MchCod);
}
static void Mch_SetMatchAsNotBeingPlayed (long MchCod)
{
/***** Delete all match players ******/
DB_QueryDELETE ("can not update match players",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_players"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld",
MchCod);
/***** Delete match as being played ******/
DB_QueryDELETE ("can not set match as not being played",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_playing"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld",
MchCod);
}
static bool Mch_GetIfMatchIsBeingPlayed (long MchCod)
{
/***** Get if a match is being played or not *****/
return
(bool) (DB_QueryCOUNT ("can not get if match is being played",
Version19.4
2019-09-17 01:37:07 +02:00
"SELECT COUNT(*) FROM mch_playing"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld",
MchCod) != 0);
}
static void Mch_RegisterMeAsPlayerInMatch (long MchCod)
{
/***** Insert me as match player *****/
DB_QueryREPLACE ("can not insert match player",
Version19.4
2019-09-17 01:37:07 +02:00
"REPLACE mch_players (MchCod,UsrCod) VALUES (%ld,%ld)",
Version19.1
2019-09-14 12:59:34 +02:00
MchCod,Gbl.Usrs.Me.UsrDat.UsrCod);
}
static void Mch_GetNumPlayers (struct Match *Match)
{
/***** Get number of players who are playing a match *****/
Version19.4
2019-09-17 01:37:07 +02:00
Match->Status.NumPlayers =
(unsigned) DB_QueryCOUNT ("can not get number of players",
"SELECT COUNT(*) FROM mch_players"
" WHERE MchCod=%ld",
Match->MchCod);
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
/******************* Show the results of a finished match ********************/
/*****************************************************************************/
void Mch_ShowFinishedMatchResults (void)
{
Ale_ShowAlert (Ale_INFO,"To be implemented...");
}
/*****************************************************************************/
/********************** Get code of match being played ***********************/
/*****************************************************************************/
void Mch_GetMatchBeingPlayed (void)
{
/***** Get match code ****/
if ((Gbl.Games.MchCodBeingPlayed = Mch_GetParamMatchCod ()) == -1L)
Lay_ShowErrorAndExit ("Code of match is missing.");
}
/*****************************************************************************/
/********* Show game being played to me as student in a new window ***********/
/*****************************************************************************/
void Mch_ShowMatchToMeAsStd (void)
{
struct Match Match;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForStd (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
/****************** Refresh match for a teacher via AJAX *********************/
/*****************************************************************************/
void Mch_RefreshMatchTch (void)
{
struct Match Match;
if (!Gbl.Session.IsOpen) // If session has been closed, do not write anything
return;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Update match status in database *****/
Mch_UpdateMatchStatusInDB (&Match);
/***** Update elapsed time in this question *****/
Mch_UpdateElapsedTimeInQuestion (&Match);
/***** Show current match status *****/
Mch_ShowMatchStatusForTch (&Match);
}
/*****************************************************************************/
/*************** Refresh current game for a student via AJAX *****************/
/*****************************************************************************/
void Mch_RefreshMatchStd (void)
{
struct Match Match;
if (!Gbl.Session.IsOpen) // If session has been closed, do not write anything
return;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Show current match status *****/
Mch_ShowMatchStatusForStd (&Match);
}
/*****************************************************************************/
/**** Receive previous question answer in a match question from database *****/
/*****************************************************************************/
static int Mch_GetQstAnsFromDB (long MchCod,unsigned QstInd)
{
MYSQL_RES *mysql_res;
MYSQL_ROW row;
unsigned NumRows;
int StdAnsInd = -1; // <0 ==> no answer selected
/***** Get student's answer *****/
NumRows = (unsigned) DB_QuerySELECT (&mysql_res,"can not get student's answer to a match question",
Version19.4
2019-09-17 01:37:07 +02:00
"SELECT AnsInd FROM mch_answers"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld AND UsrCod=%ld AND QstInd=%u",
MchCod,
Gbl.Usrs.Me.UsrDat.UsrCod,
QstInd);
if (NumRows) // Answer found...
{
/***** Get answer index *****/
row = mysql_fetch_row (mysql_res);
if (sscanf (row[0],"%d",&StdAnsInd) != 1)
Lay_ShowErrorAndExit ("Error when getting student's answer to a match question.");
}
/***** Free structure that stores the query result *****/
DB_FreeMySQLResult (&mysql_res);
return StdAnsInd;
}
/*****************************************************************************/
/********* Receive question answer from student when playing a match *********/
/*****************************************************************************/
void Mch_ReceiveQstAnsFromStd (void)
{
struct Match Match;
unsigned QstInd;
unsigned StdAnsInd;
int PreviousStdAnsInd;
/***** Remove old players.
This function must be called before getting match status. *****/
Mch_RemoveOldPlayers ();
/***** Get data of the match from database *****/
Match.MchCod = Gbl.Games.MchCodBeingPlayed;
Mch_GetDataOfMatchByCod (&Match);
/***** Get question index from form *****/
QstInd = Gam_GetParamQstInd ();
/***** Check that question index is the current one being played *****/
if (QstInd == Match.Status.QstInd) // Receiving an answer
// to the current question being played
{
/***** Get answer index *****/
/*-------+--------------+
| Button | Answer index |
+--------+--------------+
| a | 0 |
| b | 1 |
| c | 2 |
| d | 3 |
| ... | ... |
+--------+-------------*/
StdAnsInd = Mch_GetParamAnswer ();
/***** Get previous student's answer to this question
(<0 ==> no answer) *****/
PreviousStdAnsInd = Mch_GetQstAnsFromDB (Match.MchCod,QstInd);
/***** Store student's answer *****/
if (PreviousStdAnsInd == (int) StdAnsInd)
DB_QueryDELETE ("can not register your answer to the match question",
Version19.4
2019-09-17 01:37:07 +02:00
"DELETE FROM mch_answers"
Version19.1
2019-09-14 12:59:34 +02:00
" WHERE MchCod=%ld AND UsrCod=%ld AND QstInd=%u",
Match.MchCod,Gbl.Usrs.Me.UsrDat.UsrCod,QstInd);
else
DB_QueryREPLACE ("can not register your answer to the match question",
Version19.4
2019-09-17 01:37:07 +02:00
"REPLACE mch_answers"
Version19.1
2019-09-14 12:59:34 +02:00
" (MchCod,UsrCod,QstInd,AnsInd)"
" VALUES"
" (%ld,%ld,%u,%u)",
Match.MchCod,Gbl.Usrs.Me.UsrDat.UsrCod,QstInd,StdAnsInd);
}
/***** Show current match status *****/
fprintf (Gbl.F.Out,"<div id=\"game\" class=\"MATCH_CONT\">");
Mch_ShowMatchStatusForStd (&Match);
fprintf (Gbl.F.Out,"</div>");
}
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
/*** Get number of users who selected this answer and draw proportional bar **/
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
void Mch_GetAndDrawBarNumUsrsWhoHaveChosenAns (long MchCod,unsigned QstInd,unsigned AnsInd,
unsigned NumAnswerersQst,bool Correct)
Version19.1
2019-09-14 12:59:34 +02:00
{
Version19.3
2019-09-16 00:15:40 +02:00
unsigned NumAnswerersAns;
/***** Get number of users who selected this answer *****/
NumAnswerersAns = Mch_GetNumUsrsWhoHaveChosenAns (MchCod,QstInd,AnsInd);
/***** Show stats of this answer *****/
Mch_DrawBarNumUsrs (NumAnswerersAns,NumAnswerersQst,Correct);
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
/******* Get number of users who have answered a question in a match *********/
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
unsigned Mch_GetNumUsrsWhoHaveAnswerQst (long MchCod,unsigned QstInd)
Version19.1
2019-09-14 12:59:34 +02:00
{
Version19.3
2019-09-16 00:15:40 +02:00
/***** Get number of users who have answered
a question in a match from database *****/
return
(unsigned) DB_QueryCOUNT ("can not get number of users who hasve answered a question",
Version19.4
2019-09-17 01:37:07 +02:00
"SELECT COUNT(*) FROM mch_answers"
Version19.3
2019-09-16 00:15:40 +02:00
" WHERE MchCod=%ld AND QstInd=%u",
MchCod,QstInd);
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
/*** Get number of users who have chosen a given answer of a game question ***/
Version19.1
2019-09-14 12:59:34 +02:00
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
static unsigned Mch_GetNumUsrsWhoHaveChosenAns (long MchCod,unsigned QstInd,unsigned AnsInd)
Version19.1
2019-09-14 12:59:34 +02:00
{
/***** Get number of users who have chosen
an answer of a question from database *****/
Version19.3
2019-09-16 00:15:40 +02:00
return
(unsigned) DB_QueryCOUNT ("can not get number of users who have chosen an answer",
Version19.4
2019-09-17 01:37:07 +02:00
"SELECT COUNT(*) FROM mch_answers"
Version19.3
2019-09-16 00:15:40 +02:00
" WHERE MchCod=%ld AND QstInd=%u AND AnsInd=%u",
MchCod,QstInd,AnsInd);
Version19.1
2019-09-14 12:59:34 +02:00
}
/*****************************************************************************/
/***************** Draw a bar with the percentage of answers *****************/
/*****************************************************************************/
Version19.3
2019-09-16 00:15:40 +02:00
// #define Mch_MAX_BAR_WIDTH 400
#define Mch_MAX_BAR_WIDTH 100
Version19.1
2019-09-14 12:59:34 +02:00
Version19.3
2019-09-16 00:15:40 +02:00
static void Mch_DrawBarNumUsrs (unsigned NumAnswerersAns,unsigned NumAnswerersQst,bool Correct)
Version19.1
2019-09-14 12:59:34 +02:00
{
extern const char *Txt_of_PART_OF_A_TOTAL;
Version19.3
2019-09-16 00:15:40 +02:00
unsigned i;
Version19.1
2019-09-14 12:59:34 +02:00
unsigned BarWidth = 0;
/***** String with the number of users *****/
Version19.3
2019-09-16 00:15:40 +02:00
if (NumAnswerersQst)
Version19.1
2019-09-14 12:59:34 +02:00
snprintf (Gbl.Title,sizeof (Gbl.Title),
"%u&nbsp;(%u%%&nbsp;%s&nbsp;%u)",
Version19.3
2019-09-16 00:15:40 +02:00
NumAnswerersAns,
(unsigned) ((((float) NumAnswerersAns * 100.0) / (float) NumAnswerersQst) + 0.5),
Txt_of_PART_OF_A_TOTAL,NumAnswerersQst);
Version19.1
2019-09-14 12:59:34 +02:00
else
snprintf (Gbl.Title,sizeof (Gbl.Title),
"0&nbsp;(0%%&nbsp;%s&nbsp;%u)",
Version19.3
2019-09-16 00:15:40 +02:00
Txt_of_PART_OF_A_TOTAL,NumAnswerersQst);
/***** Start container *****/
fprintf (Gbl.F.Out,"<div class=\"MATCH_RESULT\">");
Version19.1
2019-09-14 12:59:34 +02:00
/***** Draw bar with a with proportional to the number of clicks *****/
Version19.3
2019-09-16 00:15:40 +02:00
if (NumAnswerersAns && NumAnswerersQst)
BarWidth = (unsigned) ((((float) NumAnswerersAns * (float) Mch_MAX_BAR_WIDTH) /
(float) NumAnswerersQst) + 0.5);
/***** Bar proportional to number of users *****/
Tbl_StartTableWide (0);
fprintf (Gbl.F.Out,"<tr class=\"MATCH_RES_TR\">");
for (i = 0;
i < 100;
i++)
fprintf (Gbl.F.Out,"<td class=\"%s\"></td>",
(i < BarWidth) ? (Correct ? "MATCH_RES_CORRECT" :
"MATCH_RES_WRONG") :
"MATCH_RES_VOID");
fprintf (Gbl.F.Out,"</tr>");
Tbl_EndTable ();
Version19.1
2019-09-14 12:59:34 +02:00
/***** Write the number of users *****/
fprintf (Gbl.F.Out,"%s",Gbl.Title);
Version19.3
2019-09-16 00:15:40 +02:00
/***** End container *****/
fprintf (Gbl.F.Out,"</div>");
Version19.1
2019-09-14 12:59:34 +02:00
}