← Back to branch summary

~ubuntu-branches/ubuntu/wily/sgt-puzzles/wily

« back to all changes in this revision

Viewing changes to slant.c

  • Committer: Package Import Robot
  • Author(s): Ben Hutchings
  • Date: 2013-06-30 03:20:16 UTC
  • mfrom: (1.2.13)
  • Revision ID: package-import@ubuntu.com-20130630032016-v8xqt6vtg6tgs420
Tags: 9872-1
http://bugs.debian.org/713476
http://bugs.debian.org/667963
* New upstream version
  - Add an explicit -lm to the link lines in Makefile.gtk (Closes: #713476)
  - Add Undead by Steffen Bauer, an implementation of 'Haunted Mirror Maze'
  - Add Unruly by Lennard Sprong, an implementation of a puzzle usually
    called 'Tohu wa Vohu'
* Add DEP-3 headers to patches
* pearl: Require width or height to be at least 6 for Tricky
  (Closes: #667963)
* debian/watch: Update ViewVC URL regex
* Add 'sgt-' prefix to all command names and remove 'game' suffix, but
  retain symlinks under the old names (see #684193)
* Use upstream short descriptions in English manual pages and package
  description
* Update German translation, thanks to Helge Kreutzmann

Show diffs side-by-side

added added

removed removed

Lines of Context:
slant.c
137
137
    sfree(params);
138
138
}
139
139
 
140
 
static game_params *dup_params(game_params *params)
 
140
static game_params *dup_params(const game_params *params)
141
141
{
142
142
    game_params *ret = snew(game_params);
143
143
    *ret = *params;                    /* structure copy */
163
163
    }
164
164
}
165
165
 
166
 
static char *encode_params(game_params *params, int full)
 
166
static char *encode_params(const game_params *params, int full)
167
167
{
168
168
    char data[256];
169
169
 
174
174
    return dupstr(data);
175
175
}
176
176
 
177
 
static config_item *game_configure(game_params *params)
 
177
static config_item *game_configure(const game_params *params)
178
178
{
179
179
    config_item *ret;
180
180
    char buf[80];
206
206
    return ret;
207
207
}
208
208
 
209
 
static game_params *custom_params(config_item *cfg)
 
209
static game_params *custom_params(const config_item *cfg)
210
210
{
211
211
    game_params *ret = snew(game_params);
212
212
 
217
217
    return ret;
218
218
}
219
219
 
220
 
static char *validate_params(game_params *params, int full)
 
220
static char *validate_params(const game_params *params, int full)
221
221
{
222
222
    /*
223
223
     * (At least at the time of writing this comment) The grid
1063
1063
    sfree(connected);
1064
1064
}
1065
1065
 
1066
 
static char *new_game_desc(game_params *params, random_state *rs,
 
1066
static char *new_game_desc(const game_params *params, random_state *rs,
1067
1067
                           char **aux, int interactive)
1068
1068
{
1069
1069
    int w = params->w, h = params->h, W = w+1, H = h+1;
1216
1216
    return desc;
1217
1217
}
1218
1218
 
1219
 
static char *validate_desc(game_params *params, char *desc)
 
1219
static char *validate_desc(const game_params *params, const char *desc)
1220
1220
{
1221
1221
    int w = params->w, h = params->h, W = w+1, H = h+1;
1222
1222
    int area = W*H;
1241
1241
    return NULL;
1242
1242
}
1243
1243
 
1244
 
static game_state *new_game(midend *me, game_params *params, char *desc)
 
1244
static game_state *new_game(midend *me, const game_params *params,
 
1245
                            const char *desc)
1245
1246
{
1246
1247
    int w = params->w, h = params->h, W = w+1, H = h+1;
1247
1248
    game_state *state = snew(game_state);
1276
1277
    return state;
1277
1278
}
1278
1279
 
1279
 
static game_state *dup_game(game_state *state)
 
1280
static game_state *dup_game(const game_state *state)
1280
1281
{
1281
1282
    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
1282
1283
    game_state *ret = snew(game_state);
1484
1485
    return TRUE;
1485
1486
}
1486
1487
 
1487
 
static char *solve_game(game_state *state, game_state *currstate,
1488
 
                        char *aux, char **error)
 
1488
static char *solve_game(const game_state *state, const game_state *currstate,
 
1489
                        const char *aux, char **error)
1489
1490
{
1490
1491
    int w = state->p.w, h = state->p.h;
1491
1492
    signed char *soln;
1549
1550
    return move;
1550
1551
}
1551
1552
 
1552
 
static int game_can_format_as_text_now(game_params *params)
 
1553
static int game_can_format_as_text_now(const game_params *params)
1553
1554
{
1554
1555
    return TRUE;
1555
1556
}
1556
1557
 
1557
 
static char *game_text_format(game_state *state)
 
1558
static char *game_text_format(const game_state *state)
1558
1559
{
1559
1560
    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
1560
1561
    int x, y, len;
1600
1601
    int cur_x, cur_y, cur_visible;
1601
1602
};
1602
1603
 
1603
 
static game_ui *new_ui(game_state *state)
 
1604
static game_ui *new_ui(const game_state *state)
1604
1605
{
1605
1606
    game_ui *ui = snew(game_ui);
1606
1607
    ui->cur_x = ui->cur_y = ui->cur_visible = 0;
1612
1613
    sfree(ui);
1613
1614
}
1614
1615
 
1615
 
static char *encode_ui(game_ui *ui)
 
1616
static char *encode_ui(const game_ui *ui)
1616
1617
{
1617
1618
    return NULL;
1618
1619
}
1619
1620
 
1620
 
static void decode_ui(game_ui *ui, char *encoding)
 
1621
static void decode_ui(game_ui *ui, const char *encoding)
1621
1622
{
1622
1623
}
1623
1624
 
1624
 
static void game_changed_state(game_ui *ui, game_state *oldstate,
1625
 
                               game_state *newstate)
 
1625
static void game_changed_state(game_ui *ui, const game_state *oldstate,
 
1626
                               const game_state *newstate)
1626
1627
{
1627
1628
}
1628
1629
 
1666
1667
    long *todraw;
1667
1668
};
1668
1669
 
1669
 
static char *interpret_move(game_state *state, game_ui *ui, game_drawstate *ds,
1670
 
                            int x, int y, int button)
 
1670
static char *interpret_move(const game_state *state, game_ui *ui,
 
1671
                            const game_drawstate *ds,
 
1672
                            int x, int y, int button)
1671
1673
{
1672
1674
    int w = state->p.w, h = state->p.h;
1673
1675
    int v;
1742
1744
    return NULL;
1743
1745
}
1744
1746
 
1745
 
static game_state *execute_move(game_state *state, char *move)
 
1747
static game_state *execute_move(const game_state *state, const char *move)
1746
1748
{
1747
1749
    int w = state->p.w, h = state->p.h;
1748
1750
    char c;
1789
1791
 * Drawing routines.
1790
1792
 */
1791
1793
 
1792
 
static void game_compute_size(game_params *params, int tilesize,
1793
 
                              int *x, int *y)
 
1794
static void game_compute_size(const game_params *params, int tilesize,
 
1795
                              int *x, int *y)
1794
1796
{
1795
1797
    /* fool the macros */
1796
1798
    struct dummy { int tilesize; } dummy, *ds = &dummy;
1801
1803
}
1802
1804
 
1803
1805
static void game_set_size(drawing *dr, game_drawstate *ds,
1804
 
                          game_params *params, int tilesize)
 
1806
                          const game_params *params, int tilesize)
1805
1807
{
1806
1808
    ds->tilesize = tilesize;
1807
1809
}
1837
1839
    return ret;
1838
1840
}
1839
1841
 
1840
 
static game_drawstate *game_new_drawstate(drawing *dr, game_state *state)
 
1842
static game_drawstate *game_new_drawstate(drawing *dr, const game_state *state)
1841
1843
{
1842
1844
    int w = state->p.w, h = state->p.h;
1843
1845
    int i;
1970
1972
    draw_update(dr, COORD(x), COORD(y), TILESIZE, TILESIZE);
1971
1973
}
1972
1974
 
1973
 
static void game_redraw(drawing *dr, game_drawstate *ds, game_state *oldstate,
1974
 
                        game_state *state, int dir, game_ui *ui,
1975
 
                        float animtime, float flashtime)
 
1975
static void game_redraw(drawing *dr, game_drawstate *ds,
 
1976
                        const game_state *oldstate, const game_state *state,
 
1977
                        int dir, const game_ui *ui,
 
1978
                        float animtime, float flashtime)
1976
1979
{
1977
1980
    int w = state->p.w, h = state->p.h, W = w+1, H = h+1;
1978
1981
    int x, y;
2059
2062
    }
2060
2063
}
2061
2064
 
2062
 
static float game_anim_length(game_state *oldstate, game_state *newstate,
2063
 
                              int dir, game_ui *ui)
 
2065
static float game_anim_length(const game_state *oldstate,
 
2066
                              const game_state *newstate, int dir, game_ui *ui)
2064
2067
{
2065
2068
    return 0.0F;
2066
2069
}
2067
2070
 
2068
 
static float game_flash_length(game_state *oldstate, game_state *newstate,
2069
 
                               int dir, game_ui *ui)
 
2071
static float game_flash_length(const game_state *oldstate,
 
2072
                               const game_state *newstate, int dir, game_ui *ui)
2070
2073
{
2071
2074
    if (!oldstate->completed && newstate->completed &&
2072
2075
        !oldstate->used_solve && !newstate->used_solve)
2075
2078
    return 0.0F;
2076
2079
}
2077
2080
 
2078
 
static int game_status(game_state *state)
 
2081
static int game_status(const game_state *state)
2079
2082
{
2080
2083
    return state->completed ? +1 : 0;
2081
2084
}
2082
2085
 
2083
 
static int game_timing_state(game_state *state, game_ui *ui)
 
2086
static int game_timing_state(const game_state *state, game_ui *ui)
2084
2087
{
2085
2088
    return TRUE;
2086
2089
}
2087
2090
 
2088
 
static void game_print_size(game_params *params, float *x, float *y)
 
2091
static void game_print_size(const game_params *params, float *x, float *y)
2089
2092
{
2090
2093
    int pw, ph;
2091
2094
 
2097
2100
    *y = ph / 100.0F;
2098
2101
}
2099
2102
 
2100
 
static void game_print(drawing *dr, game_state *state, int tilesize)
 
2103
static void game_print(drawing *dr, const game_state *state, int tilesize)
2101
2104
{
2102
2105
    int w = state->p.w, h = state->p.h, W = w+1;
2103
2106
    int ink = print_mono_colour(dr, 0);