fixed bug with potentially changing global variable in thread

When automatically incrementing level after solved game, the global
variable to store the level number may be changed while the thread
to upload the score to the server is just using it, which may cause
the score to be submitted for the wrong level number.

To fix this, the (already existing) local variable with the level
number is used instead.

changed thread functions to be more generic regarding passed data

added level name/author and "rate time over score" flag when adding score

removed "rate time over score" flag when downloading scores

removed unneeded newline characters in error output

added escaping special characters in JSON strings for HTTP requests

added converting HTTP request to server encoding when downloading scores

added functions for JSON handling

added updating game panel values immediately after solving game

moved updating game panel values after solving game to separate function

added some comments

fixed displaying invalid panel values when finishing a game

This change fixes a graphical bug that occurs when the player solves a
game by entering the exit. During that last movement, the level time
in the game panel is displayed incorrectly as zero, because the final
game values for time, score etc. are calculated not before the player
has completed the last step (while the panel values are displayed from
different variables in the last stage after winning a game).

This is a fix for commit ef1162b3.

moved setting level settings for Sokoban levels to separate function

added adjusting score settings for Sokoban levels

moved setting auto-exit for Sokoban-style levels from runtime to level

added adjusting level settings for (non-native) Sokoban-style levels

added adjusting some level settings after loading level (not used yet)

added support for toggling team mode in main menu using cursor keys

code cleanup (by using function to reset delay counter)

changed name of preprocessor macro

changed how custom elements change to player if they are walkable

Before this change, if a walkable CE changes to the player, the player
is placed on the CE, which will be kept under the player (so it does
not really change to the player, but just adds the player). This is
probably not the expected behaviour when changing a CE to the player
(but may make sense when using the "extended change target", placing
the player on one of the surrounding elements if they are walkable).

This change fixes this behaviour, so by default a CE that "changes to
the player" is replaced by the player, and not just adds the player.
However, a config option was added to the player element to explicitly
request the previous behaviour (which is used by the "Zelda II" level
set, for example).

added waiting for finished snapping when snapping envelope

added improved element collecting animations

added command line function to write element collecting image to directory

renamed command to create level sketch images

added marking all images from non-default graphics directory as "redefined"

This change is required for the case of custom graphics sets that
replace graphics by simply adding an image file with the same filename
as the default graphics, like "RocksElements.png", but without adding
changed graphics definitions in a "graphicsinfo.conf" config file.

This caused the new (custom) image file to be loaded instead of the
default image file, but did not mark the affected game graphics in the
custom image file to be "redefined" so far (which is required to
invalidate related action or direction graphics loaded from other
image files, which are now overridden by the new base graphics).

This change marks all graphics in such images files as "redefined".

changed variable and preprocessor definition names for game base directory

removed unused code for writable game data directory

removed unused code for common (system-wide) data directory

removed support for global (common/system-wide) scores directory

added setup option to force showing local scores only

forced displaying last added high score entry

added saving score tape and server score if score not added to local scores

fixed skipping historic score entries with empty tape basename

moved flag for unique score entry per player name to function parameter

fixed checking player name when adding new score entry

added dumping levels and tapes by level set and number

added "rate time over score" flag when dumping level

added special summary when playing/testing tape by filename

moved some expressions for "autotest" result to separate variables

changed "autotest" result from "OK" to "WARN" if no tapes were played

added support for playing/testing tape by filename

added using hostname for high score server from setup file

added runtime flag to store if high score server is available

added setup option to enable or disable using high score server

removed merging local and server scores after loading server scores

added reloading server scores after download has finished

added loading/saving high scores from/to score server as thread

added function to load and merge local and server scores

minor code change

added allocating memory buffers that are too large for the stack

removed local variables only used for storing copy of global variable

removed function parameter only used for storing copy of global variable

removed local variable only used for storing copy of global variable

moved calculating first entry on high score screen to separate function

added freeing buffer for Base64 encoded file

added loading high scores from score server

added functions to handle score cache files and directories

added saving high scores to score server

extended function to set score info structure to default values

added last added score entry position to score info structure

fixed saving already erased score tape

fixed saving score tape if no tape was recorded

improved (and fixed) adding new score entry

moved adding new score entry to separate function

renamed function

changed variable name

changed variable name

added functions to convert between HTTP client and server encoding

added functions to convert between ISO-8859-1 and UTF-8

added basic HTTP support

cleanup of code for Base64 encoding and decoding

added Base64 encoding and decoding to libgame header file

minor whitespace change

added initial code for Base64 encoding and decoding

added saving tape basename for each high score entry

minor whitespace change

added saving tape for each high score entry

minor code improvement

fixed mouse button CE change events for older levels

fixed counting last step when using steps instead of seconds

Before this change, the very last step was not counted anymore when
using steps instead of seconds/frames and the game already being
marked as "solved".

This change (together with the previous commit) fixes this bug.

changed calculating final game values when game is really over

Before this change, final game values (like final score and final
playing time or steps) were calculated before the game was really
over (but instead at the time the player started moving to the exit).

This especially caused calculating a wrong playing time that did not
include the time the player needed to finally reach the exit, which
was especially wrong when using steps instead of seconds/frames to
count the playing time, as the very last step was always missing in
this case.

This change fixes this bug by moving the code to calculate the final
game values to a later point where there is no player action anymore.

added some comments

cleanup of function to get high score list text entry

moved converting score to time from high score screen to score file loader

changed loading native Supaplex levels to rate high scores by playing time

added level editor option to sort high scores by playing time (or steps)

changed high score screen to show time instead of score for Supaplex levels

moved filesystem code for Emscripten platform to separate functions

added using played time for high score calculation

added storing played time in score files (not used yet)

improved code for final time calculation

cleanup of high score data structures

removed unused code

changed file format of score files from plain text to IFF

changed flood fill function to prevent stack overflow crashes

The previous implementation of the flood fill function (as used in the
level editor) used recursion, which could cause the program to crash
on some systems when using it with maximum level size. This was caused
by a stack overflow on systems that use a stack size not large enough
for the deep recursion involved in such cases. (Such crashes happened
on Windows systems, which usually have a stack size of 1 MB, while it
did not happen on Linux systems, which usually have 8 MB stack size.)

The new flood fill function which uses an iterative algorithm does not
have this problem (as the memory used for it is not on the stack).

added freeing bitmap (potentially replaced after scaling up)

added some cleanup and comments

fixed using custom sized game graphics also for global animations

When using image files for game graphics with custom tile size, then
configuring the same image files also for global animations, global
animations had broken (standard-sized) graphics before.

This change (together with the previous commit) fixes this bug.

added support for accessing (scaled) original size of loaded images

Before, loaded images were stored and accessed in "standard" size,
with an exception for game element graphics in non-standard size (like
using game element graphics with a tile size of 64x64 pixels).

This has the disadvantage that global animations using the same image
file are displayed incorrectly, because of not using the original size
of the image, but the (potentially down-scaled) "standard" image size
(as the original sized graphics are only used for game elements).

This change adds a bitmap pointer to easily access the original sized
bitmap (which can either be the normal, standard-sized bitmap, or the
custom sized bitmap used for in-game element graphics). In addition,
the original sized bitmap is also stored in cases where it would have
been discarded before (like image files with double-sized element
graphics used in graphics sets that only use standard sized element
graphics, which causes the original bitmap to be down-scaled and freed
again, only keeping the down-scaled bitmap, so the bitmap in original
size is not available anymore for global animations using the same
image file).

When talking about "original sized bitmaps" here, this is the size of
the image _after_ applying a possible option "scale_up_factor", which
is always applied first.

Correctly using the "original sized bitmaps" for global animations
will be fixed with the next commit.