planarity/graph_generate.c

   1 /*
   2  *
   3  *  gPlanarity:
   4  *     The geeky little puzzle game with a big noodly crunch!
   5  *
   6  *     gPlanarity copyright (C) 2005 Monty <monty@xiph.org>
   7  *     Original Flash game by John Tantalo <john.tantalo@case.edu>
   8  *     Original game concept by Mary Radcliffe
   9  *
  10  *  gPlanarity is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2, or (at your option)
  13  *  any later version.
  14  *
  15  *  gPlanarity is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with Postfish; see the file COPYING.  If not, write to the
  22  *  Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23  *
  24  *
  25  */
  26
  27 #define _GNU_SOURCE
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include "graph.h"
  31 #include "graph_generate.h"
  32 #include "nls.h"
  33
  34 typedef struct {
  35   char *class;
  36   int instancenum;
  37   char *desc;
  38   void (*gen)(graph *g, int num);
  39   float intersection_mult;
  40   float objective_mult;
  41   int unlock;
  42 } gen_instance;
  43
  44 #define FINITE_LEVELS 79
  45 static gen_instance i_list[FINITE_LEVELS]={
  46
  47   {"simple",   1, "A Small Beginning",                              generate_simple,    1.,4., 1 }, // 1
  48   {"simple",   2, "My First Real Level(tm)",                        generate_simple,    1.,4., 2 }, // 2
  49   {"data",     0, "My First Mission Impossible(tm)",                generate_data,     20.,4., 3 }, // 3
  50   {"simple",   3, "Larger But Not Harder",                          generate_simple,    1.,4., 2 }, // 4
  51   {"crest",    5, "The Trick Is It's Easy",                         generate_crest,     1.,4., 2 }, // 5
  52
  53   {"simple",   4, "Practice Before the Handbasket: One of Three",   generate_simple,    1.,4., 2 }, // 6
  54   {"simple",   5, "Practice Before the Handbasket: Two of Three",   generate_simple,    1.,4., 2 }, // 7
  55   {"simple",   6, "Practice Before the Handbasket: Three of Three", generate_simple,    1.,4., 2 }, // 8
  56
  57   {"sparse",   4, "Tough and Stringy",                              generate_sparse,    1.2,4., 2 }, // 9
  58   {"sparse",   5, "Threadbare",                                     generate_sparse,    1.2,4., 2 }, // 10
  59
  60   {"nasty",    4, "The Bumpy Circles Are Slightly More Difficult",  generate_nasty,    1.5,4., 3 }, // 11
  61   {"nasty",    5, "Three is a Magic Number",                        generate_nasty,    1.5,4., 3 }, // 12
  62   {"nasty",    6, "Last Call For (Sort of) Triangles (For Now)",    generate_nasty,    1.5,4., 3 }, // 13
  63
  64   {"free",     4, "Something Only Subtly Different",                generate_freeform, 1.5,4., 3 }, // 14
  65   {"free",     5, "It Can Roll! Granted, Not Very Well",            generate_freeform, 1.5,4., 3 }, // 15
  66   {"free",     6, "If You Squint, It's a Round Brick",              generate_freeform, 1.5,4., 3 }, // 16
  67
  68   {"rogue",    5, "A New Objective",                                generate_rogue,    1.6,4., 3 }, // 17
  69   {"rogue",    6, "How Low Can You Go?",                            generate_rogue,    1.6,4., 3 }, // 18
  70   {"rogue",    7, "Military Industrial Complex",                    generate_rogue,    1.6,4., 4 }, // 19
  71
  72   {"embed",    4, "The Hexagon is a Subtle and Wily Beast",         generate_embed,     2.,4.,  4 }, // 20
  73   {"embed",    5, "No, Really, The Hexagon Puzzles Are Harder",     generate_embed,     3.,4.,  5 }, // 21
  74   {"embed",    6, "Cursed?  Call 1-800-HEX-A-GON Today!",           generate_embed,     4.,4.,  6 }, // 22
  75
  76   {"simple",   7, "Round but Straightforward",                      generate_simple,    1.,4.,  4 }, // 23
  77
  78   {"shape",    0, "A Star Is Born... Then Solved",                  generate_shape,    1.,2.,  6 }, // 24
  79   {"shape",    1, "Oh, Rain*bows*...",                              generate_shape,    1.,2.,  6 }, // 25
  80   {"shape",    2, "Solve Along the Dotted Line",                    generate_shape,    1.,2.,  6 }, // 26
  81   {"shape",    3, "Using All Available Space",                      generate_shape,    1.,2.,  6 }, // 27
  82   {"shape",    4, "Brainfreeze",                                    generate_shape,    1.,2.,  6 }, // 28
  83   {"shape",    6, "Tropical Storm Invest",                          generate_shape,    1.,2.,  6 }, // 30
  84
  85   {"dense",  8, "Algorithm: Original/Dense (Order: 8)", generate_dense,     .8,1., 5 }, // 31
  86   {"simple", 8, "Algorithm: Original (Order: 8)",       generate_simple,    1.,1., 6 }, // 32
  87   {"sparse", 8, "Algorithm: Original/Sparse (Order: 8)",generate_sparse,   1.2,1., 7 }, // 33
  88   {"nasty",  8, "Algorithm: Nasty (Order: 8)",          generate_nasty,    1.5,1., 8 }, // 34
  89   {"free",   8, "Algorithm: Freeform/4 (Order: 8)",     generate_freeform, 1.5,1., 9 }, // 35
  90   {"rogue",  8, "Algorithm: Rogue (Order: 8)",          generate_rogue,    1.6,1.,10 }, // 36
  91   {"embed",  8, "Algorithm: Embed (Order: 8)",          generate_embed,     4.,1.,10 }, // 37
  92   {"shape",  7, "Operator",                             generate_shape,     1.,2.,10 }, // 38
  93
  94   {"dense",  9, "Algorithm: Original/Dense (Order: 9)", generate_dense,     .8,1., 5 }, // 39
  95   {"simple", 9, "Algorithm: Original (Order: 9)",       generate_simple,    1.,1., 6 }, // 40
  96   {"sparse", 9, "Algorithm: Original/Sparse (Order: 9)",generate_sparse,   1.2,1., 7 }, // 41
  97   {"nasty",  9, "Algorithm: Nasty (Order: 9)",          generate_nasty,    1.5,1., 8 }, // 42
  98   {"free",   9, "Algorithm: Freeform/4 (Order: 9)",     generate_freeform, 1.5,1., 9 }, // 43
  99   {"rogue",  9, "Algorithm: Rogue (Order: 9)",          generate_rogue,    1.6,1.,10 }, // 44
 100   {"embed",  9, "Algorithm: Embed (Order: 9)",          generate_embed,     4.,1.,10 }, // 45
 101   {"shape",  8, "The Inside Is Pointy",                 generate_shape,     1.,2.,10 }, // 46
 102
 103   {"dense", 10, "Algorithm: Original/Dense (Order: 10)", generate_dense,     .8,1., 5 }, // 47
 104   {"simple",10, "Algorithm: Original (Order: 10)",       generate_simple,    1.,1., 6 }, // 48
 105   {"sparse",10, "Algorithm: Original/Sparse (Order: 10)",generate_sparse,   1.2,1., 7 }, // 49
 106   {"nasty", 10, "Algorithm: Nasty (Order: 10)",          generate_nasty,    1.5,1., 8 }, // 50
 107   {"free",  10, "Algorithm: Freeform/4 (Order: 10)",     generate_freeform, 1.5,1., 9 }, // 51
 108   {"rogue", 10, "Algorithm: Rogue (Order: 10)",          generate_rogue,    1.6,1.,10 }, // 52
 109   {"embed", 10, "Algorithm: Embed (Order: 10)",          generate_embed,     4.,1.,10 }, // 53
 110   {"shape",  9, "Riches and Good Luck",                  generate_shape,     1.,2.,10 }, // 54
 111
 112   {"dense", 11, "Algorithm: Original/Dense (Order: 11)", generate_dense,     .8,1., 5 }, // 55
 113   {"simple",11, "Algorithm: Original (Order: 11)",       generate_simple,    1.,1., 6 }, // 56
 114   {"sparse",11, "Algorithm: Original/Sparse (Order: 11)",generate_sparse,   1.2,1., 7 }, // 57
 115   {"nasty", 11, "Algorithm: Nasty (Order: 11)",          generate_nasty,    1.5,1., 8 }, // 58
 116   {"free",  11, "Algorithm: Freeform/4 (Order: 11)",     generate_freeform, 1.5,1., 9 }, // 59
 117   {"rogue", 11, "Algorithm: Rogue (Order: 11)",          generate_rogue,    1.6,1.,10 }, // 60
 118   {"embed", 11, "Algorithm: Embed (Order: 11)",          generate_embed,     4.,1.,10 }, // 61
 119   {"shape", 10, "Mmmm... Doughnut",                      generate_shape,     1.,2.,10 }, // 62
 120
 121   {"dense", 12, "Algorithm: Original/Dense (Order: 12)", generate_dense,     .8,1., 5 }, // 63
 122   {"simple",12, "Algorithm: Original (Order: 12)",       generate_simple,    1.,1., 6 }, // 64
 123   {"sparse",12, "Algorithm: Original/Sparse (Order: 12)",generate_sparse,   1.2,1., 7 }, // 65
 124   {"nasty", 12, "Algorithm: Nasty (Order: 12)",          generate_nasty,    1.5,1., 8 }, // 66
 125   {"free",  12, "Algorithm: Freeform/4 (Order: 12)",     generate_freeform, 1.5,1., 9 }, // 67
 126   {"rogue", 12, "Algorithm: Rogue (Order: 12)",          generate_rogue,    1.6,1.,10 }, // 68
 127   {"embed", 12, "Algorithm: Embed (Order: 12)",          generate_embed,     4.,1.,10 }, // 69
 128   {"shape", 11, "Quick and Dirty, or Slow and Steady",   generate_shape,     1.,1.,10 }, // 70
 129   {"shape",  5, "Little Fluffy Clouds",                   generate_shape,    1.,2., 6 }, // 29
 130
 131   {"dense", 13, "Algorithm: Original/Dense (Order: 13)", generate_dense,     .8,1., 5 }, // 71
 132   {"simple",13, "Algorithm: Original (Order: 13)",       generate_simple,    1.,1., 6 }, // 72
 133   {"sparse",13, "Algorithm: Original/Sparse (Order: 13)",generate_sparse,   1.2,1., 7 }, // 73
 134   {"nasty", 13, "Algorithm: Nasty (Order: 13)",          generate_nasty,    1.5,1., 8 }, // 74
 135   {"free",  13, "Algorithm: Freeform/4 (Order: 13)",     generate_freeform, 1.5,1., 9 }, // 75
 136   {"rogue", 13, "Algorithm: Rogue (Order: 13)",          generate_rogue,    1.6,1.,10 }, // 76
 137   {"embed", 13, "Algorithm: Embed (Order: 13)",          generate_embed,     4.,1.,10 }, // 77
 138   {"shape", 12, "A Sudden Urge To Go Shopping",          generate_shape,     1.,1.,10 }, // 78
 139   {"shape", 13, "Sweet Reward",                          generate_shape,     1.,1.,10 }, // 79
 140
 141 };
 142
 143 #define LOOP_LEVELS 8
 144 static gen_instance i_list_loop[LOOP_LEVELS]={
 145   {"dense", 14, "Algorithm: Original/Dense (Order: %d)", generate_dense,     .8,1., 5 }, // n
 146   {"simple",14, "Algorithm: Original (Order: %d)",       generate_simple,    1.,1., 6 }, // n
 147   {"sparse",14, "Algorithm: Original/Sparse (Order: %d)",generate_sparse,   1.2,1., 7 }, // n
 148   {"nasty", 14, "Algorithm: Nasty (Order: %d)",          generate_nasty,    1.5,1., 8 }, // n
 149   {"free",  14, "Algorithm: Freeform/4 (Order: %d)",     generate_freeform, 1.5,1., 9 }, // n
 150   {"rogue", 14, "Algorithm: Rogue (Order: %d)",          generate_rogue,    1.6,1.,10 }, // n
 151   {"embed", 14, "Algorithm: Embed (Order: %d)",          generate_embed,     4.,1.,10 }, // n
 152   {"shape", 14, "Algorithm: Region (Order: %d)",         generate_shape,     1.,2.,10 },
 153 };
 154
 155 int generate_find_number(char *id){
 156   int i;
 157   char buffer[160];
 158
 159   for(i=0;i<FINITE_LEVELS;i++){
 160     snprintf(buffer,160,"%s %d",i_list[i].class,i_list[i].instancenum);
 161     if(!strcmp(id,buffer))
 162       return i;
 163   }
 164
 165   {
 166     char *arg = strchr(id,' ');
 167     if(arg){
 168       unsigned int len = arg-id;
 169
 170       for(i=0;i<LOOP_LEVELS;i++){
 171         if(strlen(i_list_loop[i].class)==len &&
 172            !strncmp(i_list_loop[i].class,id,len)){
 173
 174           // class match, determine the level number
 175           int order = atoi(arg+1);
 176           return FINITE_LEVELS + (order - i_list_loop[i].instancenum)*LOOP_LEVELS + i;
 177
 178
 179         }
 180       }
 181     }
 182   }
 183
 184   return -1;
 185 }
 186
 187 int generate_get_meta(int num, graphmeta *gm){
 188   if(num<FINITE_LEVELS){
 189
 190     /* part of the finite list */
 191
 192     gm->num = num;
 193     gm->desc = _(i_list[num].desc);
 194     gm->unlock_plus = i_list[num].unlock+1;
 195     if(asprintf(&gm->id,"%s %d",i_list[num].class,i_list[num].instancenum)==-1){
 196       fprintf(stderr,_("Couldn't allocate memory for level name.\n"));
 197       return -1;
 198     }
 199     return 0;
 200   }else{
 201
 202     /* past the finite list; one of the loop levels */
 203     int classnum = (num - FINITE_LEVELS) % LOOP_LEVELS;
 204     int ordernum = (num - FINITE_LEVELS) / LOOP_LEVELS +
 205       i_list_loop[classnum].instancenum;
 206
 207     gm->num = num;
 208     gm->unlock_plus = i_list_loop[classnum].unlock+1;
 209     if(asprintf(&gm->desc,i_list_loop[classnum].desc,ordernum)==-1){
 210       fprintf(stderr,_("Couldn't allocate memory for level description.\n"));
 211       return -1;
 212     }
 213
 214     if(asprintf(&gm->id,"%s %d",i_list_loop[classnum].class,ordernum)==-1){
 215       fprintf(stderr,_("Couldn't allocate memory for level name.\n"));
 216       return -1;
 217     }
 218
 219     return 0;
 220
 221   }
 222 }
 223
 224 void generate_board(graph *g,int num){
 225   gen_instance *gi;
 226   if(num<FINITE_LEVELS){
 227     gi = i_list+num;
 228
 229     gi->gen(g,gi->instancenum);
 230   }else{
 231     int classnum = (num - FINITE_LEVELS) % LOOP_LEVELS;
 232     int ordernum = (num - FINITE_LEVELS) / LOOP_LEVELS +
 233       i_list_loop[classnum].instancenum;
 234
 235     gi = i_list_loop+classnum;
 236     gi->gen(g,ordernum);
 237   }
 238
 239   // clear out overloaded flags
 240   {
 241     vertex *v = g->verticies;
 242     while(v){
 243       v->active=0;
 244       v->selected=0;
 245       v->grabbed=0;
 246       v=v->next;
 247     }
 248   }
 249
 250   g->objective_mult = gi->objective_mult;
 251   g->intersection_mult = gi->intersection_mult;
 252 }