API tools faq
paste
Advertisement
Guest User

digging Test

a guest
Nov 29th, 2012
633
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 43.28 KB | None | 0 0
raw download clone embed print report
  1. #include <fstream>
  2. #include <ctime>    //used to initilize the random number generator
  3. #include <cstdlib>  //used for the random numbers
  4. #include <curses.h> //display
  5. #include <cmath>
  6. using namespace std;
  7. /***************************/
  8. #define forDiagonal(w) {int xdir[]={-1,-1,1,1};int ydir[]={-1,1,-1,1};int A;int B;int shuffled[]={0,1,2,3};shuffle(shuffled,4);for(int i=0;i<4;i++){A=ydir[shuffled[i]];B=xdir[shuffled[i]];if(legal(y+A,x+B)){w}}}
  9. #define forOrthogonal(w) {int xdir[]={-1,0,1,0};int ydir[]={0,-1,0,1};int A;int B;int shuffled[]={0,1,2,3};shuffle(shuffled,4);for(int i=0;i<4;i++){A=ydir[shuffled[i]];B=xdir[shuffled[i]];if(legal(y+A,x+B)){w}}}
  10. #define forTouching(w) {int xdir[]={-1,-1,-1,0,1,1,1,0};int ydir[]={-1,0,1,1,1,0,-1,-1};int A;int B;int shuffled[]={0,1,2,3,4,5,6,7,};shuffle(shuffled,8);for(int i=0;i<8;i++){A=ydir[shuffled[i]];B=xdir[shuffled[i]];if(legal(y+A,x+B)){w}}}
  11. #define show(w,z) else if(a&(w)){ return z; }
  12. #define put(a,b) else if(inchar==a){ TILES[playerY][playerX]^=b; }
  13. #define record_name(x) add_names_to_list(x,#x)
  14. #define currentlyAt(y,x,thing) (tiles[y][x]&thing)
  15. #define remove(y,x,thing) (subtract[y][x]&= ~thing)
  16. #define addAt(y,x,thing) (tiles[y][x]|=thing)
  17. /***************************/
  18. const int Y=40;             //height of world
  19. const int X=80;             //width of world
  20. const int size_of_int = 32;
  21. const int names_width=20;
  22. char NAMES[size_of_int][names_width];
  23. enum{
  24.     // to add a new thing
  25.     // add its name to the enum
  26.     // add function void Thing(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  27.     // add record_name( thing ); to init
  28.     // add "show(thing,t)" to tile_creature
  29.     // in EXACTLY the same place add "show(thing, <int> )" to color_creature
  30.     // add "put('T',thing)" to input
  31.     // add "if(isAt(y,x,thing)) Thing(y,x,tiles,subtract);" to tick
  32.     // create Thing function
  33.     // and you're done
  34.     numFields =0,
  35.     //each thing is a bit
  36.     wall=       1<<0,
  37.     dwarf1=     1<<1,
  38.     dwarf2=     1<<2,
  39.     previous=   1<<3,
  40.     door=       1<<4,
  41.     dragon=     1<<5,
  42.     grass=      1<<6,
  43.     tallgrass=  1<<7,
  44.     fire=       1<<8,
  45.     stickybush= 1<<9,
  46.     lichen=     1<<10,
  47.     moss=       1<<11,
  48.     mold=       1<<12,
  49.     moldseed=   1<<13,
  50.     slime=      1<<14,
  51.     jelly=      1<<15,
  52.     grazer=     1<<16,
  53.     runner=     1<<17,
  54.     predator=   1<<18,
  55.     stickyseed= 1<<19,
  56.     bloat=      1<<20,
  57.     coral=      1<<21,
  58.     plankton=   1<<22,
  59.     youngcoral= 1<<23,
  60.     fireweed=   1<<24,
  61.     fireweedseed=1<<25,
  62.     larva=      1<<26,
  63.     treeseed=   1<<27,
  64.     sapling=    1<<28,
  65.     tree=       1<<29,
  66.     ant=        1<<30,//
  67.     busheater=  1<<31,
  68. //not enough bits for these
  69.     reed=       0,
  70.     sedge=      0,
  71.     daisy=      0,
  72.     thing1=     0,
  73.     thing2=     0,
  74.     sage=       0,
  75.     sand=       0,
  76.     flower=     0,
  77.     shrub=      0,
  78.     livevine=   0,
  79.     vine=       0,
  80.     vineroot=   0,
  81.     paralyze=   0,
  82.    
  83.     seeds=(stickyseed |fireweedseed |moldseed |treeseed |plankton),
  84.     creature=(dwarf1 |dwarf2 |dragon |jelly |runner |grazer |ant |larva |busheater),
  85.     plant=(grass |tallgrass |slime |stickybush |fireweed |lichen |mold |vine |vineroot |tree |daisy |coral |sapling),
  86.     flamable=(tallgrass |stickybush |vine |fireweed |mold |shrub |daisy |moss), //supports flames
  87.     explosive=(fireweed),   //spreads flame to all surrounding tiles
  88.     hardtoburn=(slime |tree |sapling |lichen |coral |youngcoral),   //burns slowly
  89.     burnable=(seeds |flamable |hardtoburn |grass |fireweed |jelly |dwarf2 |dwarf1 |lichen |moss |mold |grazer |vineroot |door |flower |sage), //gets burnt up
  90.     endolithic=(lichen |moss |slime |mold),
  91.     pickupable=(stickyseed |fireweedseed |moldseed),
  92.     bush=(fireweed |stickybush |sage |vine |vineroot |coral),
  93. };
  94. /***************************/
  95. int COLOR[Y][X];        //the color of the tiles
  96. char VIEW[Y][X];        //the charecter
  97. bool visible[Y][X];
  98. int TILES[Y][X];
  99. int GOLD[Y][X];
  100. int DISTURBANCE[Y][X];  //how long since something disturbed this tile
  101. bool quit;
  102. bool xray;
  103. char inchar;
  104. bool paused;
  105. bool looking;
  106. bool showing_instructions;
  107. int playerY;
  108. int playerX;
  109. int turncount;
  110. /***************************/
  111. int bit_number(int a);
  112. bool legal(int w,int g);
  113. bool superlegal(int w,int g);
  114. bool supersuperlegal(int w,int g);
  115. bool blocked(int w,int g);
  116. bool notblocked(int w,int g);
  117. bool isAt(int y, int x,int thing);
  118. int color_creature(int a, int gold);
  119. char tile_creature(int a, int gold);
  120. void display();
  121. void init();
  122. void input();
  123. void tick();
  124. void Bloat(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  125. void Thing1(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  126. void Thing2(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  127. void Reed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  128. void Sedge(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  129. void Coral(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  130. void Plankton(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  131. void Youngcoral(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  132. void Tree(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  133. void Sapling(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  134. void Treeseed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  135. void Shrub(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  136. void Flower(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  137. void Busheater(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  138. void Ant(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  139. void Vineroot(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  140. void Vine(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  141. void Grazer(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  142. void Larva(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  143. void Fireweedseed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  144. void Fireweed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  145. void Lichen(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  146. void Moldseed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  147. void Mold(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  148. void Moss(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  149. void Stickyseed(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  150. int power(int a, int b);
  151. void Stickybush(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  152. void Runner(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  153. void Predator(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  154. void Jelly(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  155. void Slime(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  156. void Sage(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  157. void Fire(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  158. void Grass(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  159. void Tallgrass(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  160. void Dwarf1(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  161. void Dwarf2(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  162. void Dragon(int y, int x, int tiles[Y][X],int subtract[Y][X]);
  163. int touching(int y, int x, int item);
  164. int touchingNot(int y, int x, int item);
  165. int diagonal(int y, int x, int item);
  166. int diagonalNot(int y, int x, int item);
  167. int orthogonal(int y, int x, int item);
  168. int orthogonalNot(int y, int x, int item);
  169. bool koolaidman(int y, int x);
  170. bool antikoolaidman(int y, int x);
  171. bool nocorner(int y, int x);
  172. void swap(int &a,int &b);
  173. bool bresenham(int y0,int y1,int x0,int x1);
  174. void shuffle(int arry[],int length);
  175. int sign(int a);
  176. void look_tile(int tile,char creatures[size_of_int][names_width]);
  177. void add_names_to_list(int creach, char* name);
  178. /***************************/
  179. /***************************/
  180. void add_names_to_list(int creach, char* name){
  181.     int i=bit_number(creach);
  182.     if(i!=-1){
  183.         NAMES[i][0]=' ';
  184.         NAMES[i][1]= tile_creature(creach,0);
  185.         NAMES[i][2]=' ';
  186.         int j=3;
  187.         for(; j<names_width && name[j-3]!='\0'; j++){
  188.             NAMES[i][j]=name[j-3];
  189.         }
  190.         for(; j<names_width; j++){
  191.             NAMES[i][j]=' ';
  192.         }
  193.         return;
  194.     }
  195. }
  196. int bit_number(int a){
  197.     for(int i=0; i<size_of_int; i++){
  198.         if((1<<i)==a) return i;
  199.     }
  200.     return -1;
  201. }
  202. bool legal(int w,int g){ return w>=0 && w<Y && g>=0 && g<X; }
  203. bool superlegal(int w,int g){ return w>0 && w<(Y-1) && g>0 && g<(X-1);}
  204. bool supersuperlegal(int w,int g){ return w>1 && w<(Y-2) && g>1 && g<(X-2);}
  205. bool notblocked(int w,int g){
  206.     return legal(w,g) && !isAt(w,g,wall);           //within bounds of the map array
  207. }
  208. bool blocked(int w,int g){
  209.     return legal(w,g) || isAt(w,g,wall);            //within bounds of the map array
  210. }
  211. int main()
  212. {
  213.     init();
  214.     while(!quit)    //press q to quit
  215.     {
  216.         display();
  217.         input();
  218.         if(!paused && !looking){
  219.             tick();
  220.         }
  221.     }
  222.     refresh();
  223.     echo();         // turn echoing back on before exiting
  224.     endwin();       // end curses control of the window
  225. }
  226. /***************************/
  227. void init()
  228. {
  229.     xray=true;
  230.     looking=false;
  231.     quit=false;
  232.     paused=true;
  233.     turncount=0;
  234.     showing_instructions=false;
  235.     initscr();
  236.     nodelay(initscr(),true);            // don't wait for user input
  237.     srand(time(NULL));  // initializes the random number generator
  238.     clear();                // clear the window
  239.     noecho();               // don't show typed characters on the screen
  240.     start_color();
  241.         init_pair(0, COLOR_WHITE, COLOR_BLACK);
  242.         init_pair(1, COLOR_WHITE, COLOR_RED);
  243.         init_pair(2, COLOR_WHITE, COLOR_BLUE);
  244.         init_pair(3, COLOR_WHITE, COLOR_GREEN);
  245.         init_pair(4, COLOR_WHITE, COLOR_YELLOW);
  246.         init_pair(5, COLOR_RED, COLOR_YELLOW);
  247.         init_pair(6, COLOR_GREEN, COLOR_BLACK);
  248.         init_pair(7, COLOR_BLUE, COLOR_BLACK);
  249.         init_pair(8, COLOR_CYAN, COLOR_BLACK);
  250.         init_pair(9, COLOR_YELLOW, COLOR_BLACK);
  251.         init_pair(10, COLOR_RED, COLOR_BLACK);
  252.         init_pair(11, COLOR_WHITE, COLOR_CYAN);
  253.         init_pair(12, COLOR_WHITE, COLOR_MAGENTA);
  254.         init_pair(13, COLOR_BLACK, COLOR_WHITE);
  255.         init_pair(14, COLOR_MAGENTA, COLOR_WHITE);
  256.     for(int y=0; y<Y; y++)
  257.     {
  258.         for(int x=0; x<X; x++)
  259.         {
  260.             COLOR[y][x]=0;
  261.             VIEW[y][x]=' ';
  262.             TILES[y][x] = wall;
  263.             GOLD[y][x] = (rand()%16==0);
  264.             DISTURBANCE[y][x]=0;
  265.             visible[y][x]=false;
  266.         }
  267.     }
  268.     TILES[Y/2][X/2]|=dwarf1;
  269.     playerY=Y/2;
  270.     playerX=X/2;
  271.     record_name(wall);
  272.     record_name(dwarf1);
  273.     record_name(dwarf2);
  274.     record_name(previous);
  275.     record_name(door);
  276.     record_name(dragon);
  277.     record_name(grass);
  278.     record_name(tallgrass);
  279.     record_name(fire);
  280.     record_name(flower);
  281.     record_name(lichen);
  282.     record_name(moss);
  283.     record_name(mold);
  284.     record_name(moldseed);
  285.     record_name(slime);
  286.     record_name(jelly);
  287.     record_name(grazer);
  288.     record_name(runner);
  289.     record_name(predator);
  290.     record_name(paralyze);
  291.     record_name(shrub);
  292.     record_name(vine);
  293.     record_name(vineroot);
  294.     record_name(coral);
  295.     record_name(plankton);
  296.     record_name(youngcoral);
  297.     record_name(fireweed);
  298.     record_name(fireweedseed);
  299.     record_name(larva);
  300.     record_name(treeseed);
  301.     record_name(sapling);
  302.     record_name(tree);
  303.     record_name(ant);
  304.     record_name(busheater);
  305.     record_name(stickybush);
  306.     record_name(stickyseed);
  307.     record_name(reed);
  308.     record_name(sedge);
  309.     record_name(daisy);
  310.     record_name(thing1);
  311.     record_name(thing2);
  312.     record_name(sage);
  313.     record_name(sand);
  314.     record_name(bloat);
  315. }
  316. bool isAt(int y, int x,int thing){
  317.     if(legal(y,x)){ return (TILES[y][x]&thing); }
  318.     else{ return 0;}
  319. }
  320. char tile_creature(int a,int gold){
  321.     //order matters; the ones on top display over the ones lower down
  322.     if(false){}
  323.     show(busheater,'X')
  324.     show(ant,'A')
  325.     show(dragon,'D')
  326.     show(dwarf1,'d')
  327.     show(dwarf2,'d')
  328.     show(fire,'*')
  329.     show(jelly,' ')
  330.     show(runner,'R')
  331.     show(bloat,'b')
  332.     show(predator,'p')
  333.     show(grazer,'G')
  334.     show(larva,'~')
  335.     show(vine,'$')
  336.     show(fireweed,'&')
  337.     show(flower,'*')
  338.     show(vineroot,'%')
  339.     show(door,'+')
  340.     show(sage,'^')
  341.     show(thing1,' ')
  342.     show(thing2,' ')
  343.     else if(gold>0){return '0'+gold; }
  344.     show(moss,'$')
  345.     show(stickybush,'%')
  346.     show(tree,'T')
  347.     show(sapling,'t')
  348.     show(coral,'^')
  349.     show(youngcoral,'|')
  350.     show(plankton,'.')
  351.     show(shrub,'%')
  352.     show(reed,'|')
  353.     show(sedge,'|')
  354.     show(lichen,'#')
  355.     show(mold,'#')
  356.     show(slime,'#')
  357.     show(daisy,'*')
  358.     show(tallgrass,';')
  359.     show(grass,',')
  360.     show(stickyseed,'.')
  361.     show(moldseed,'.')
  362.     show(fireweedseed,'.')
  363.     show(wall,'#')
  364.     show(sand,'=')
  365.     else
  366.         return '.';
  367. }
  368.  
  369. int color_creature(int a, int gold){
  370.     if(false){}
  371.     show(busheater,4)
  372.     show(ant,10)
  373.     show(dragon,1)
  374.     show(dwarf1,1)
  375.     show(dwarf2,0)
  376.     show(fire,5)
  377.     show(jelly,1)
  378.     show(runner,0)
  379.     show(bloat,14)
  380.     show(predator,0)
  381.     show(grazer,10)
  382.     show(larva,8)
  383.     show(vine,3)
  384.     show(fireweed,10)
  385.     show(flower,8)
  386.     show(vineroot,3)
  387.     show(door,9)
  388.     show(sage,8)
  389.     show(thing1,4)
  390.     show(thing2,2)
  391.     else if(gold>0){ return 4;}
  392.     show(moss,8)
  393.     show(stickybush,7)
  394.     show(tree,6)
  395.     show(sapling,6)
  396.     show(coral,10)
  397.     show(youngcoral,10)
  398.     show(plankton,10)
  399.     show(shrub,6)
  400.     show(reed,8)
  401.     show(sedge,6)
  402.     show(lichen,9)
  403.     show(mold,2)
  404.     show(slime,6)
  405.     show(daisy,10)
  406.     show(tallgrass,9)
  407.     show(grass,9)
  408.     show(stickyseed,7)
  409.     show(moldseed,2)
  410.     show(fireweedseed,9)
  411.     show(wall,0)
  412.     show(sand,0)
  413.     show(paralyze,1)
  414.     else
  415.         return 0;
  416. }
  417.  
  418. void look_tile(int tile,char creatures[size_of_int][names_width]){
  419.     int place =0;
  420.     for(int i=0; i<size_of_int; i++){
  421.         if(tile&(1<<i)){
  422.             for(int j=0; j<names_width; j++){
  423.                 creatures[place][j] = NAMES[i][j];
  424.             }
  425.             place++;
  426.         }
  427.     }
  428.     for(; place<size_of_int; place++){
  429.         for(int j=0; j<names_width; j++){
  430.             creatures[place][j] = ' ';
  431.         }
  432.     }
  433. }
  434.  
  435. void look_color(int tile,int* colors){
  436.     int place =0;
  437.     for(int i=0; i<size_of_int; i++){
  438.         if(tile&(1<<i)){
  439.             colors[place] = color_creature((1<<i),0);
  440.             place++;
  441.         }
  442.     }
  443.     for(;place < size_of_int; place++){
  444.         colors[place] = 0;
  445.     }
  446. }
  447.  
  448. /***************************/
  449. void display()
  450. {
  451.     for(int y=-1; y<=Y; y++)//I have to do this to include the corners
  452.     {
  453.         bresenham(playerY,y,playerX,X);
  454.         bresenham(playerY,y,playerX,-1);
  455.     }
  456.     for(int x=-1; x<=X; x++)
  457.     {
  458.         bresenham(playerY,Y,playerX,x);
  459.         bresenham(playerY,-1,playerX,x);
  460.     }
  461.     for(int y=0; y<Y; y++)
  462.     {
  463.         for(int x=0; x<X; x++)
  464.         {
  465.             if(showing_instructions){
  466.                 char instructions[8][41] = {
  467.                     "     move around with the numpad       ",
  468.                     "q or Q quits                           ",
  469.                     "S saves game to a file,  / loads it    ",
  470.                     "l shows you what is on the tile        ",
  471.                     "x turns on and off the xray vision     ",
  472.                     "P pauses and unpauses the game         ",
  473.                     "spacebar advances one tick             ",
  474.                     "for the rest check the input function  "};
  475.                     int i=y-Y/2+4;
  476.                     int j=x-X/2+20;
  477.                     COLOR[y][x]=0;
  478.                     if(i>=0 && i<8 && j>=0 && j<39){
  479.                         VIEW[y][x]=instructions[i][j];
  480.                     }else{
  481.                         VIEW[y][x]=' ';
  482.                     }
  483.             }else{
  484.                 COLOR[y][x]=0;
  485.                 VIEW[y][x]=' ';
  486.                 if(visible[y][x] || xray){
  487.                     VIEW[y][x] = tile_creature(TILES[y][x],GOLD[y][x]);
  488.                     COLOR[y][x] = color_creature(TILES[y][x],GOLD[y][x]);
  489.                     if(y==playerY && x==playerX){
  490.                         VIEW[y][x]='@';
  491.                         COLOR[y][x]=0;
  492.                     }
  493.                 }
  494.                 if(looking){
  495.                     char creatures[size_of_int][names_width];
  496.                     int all_colors_at[size_of_int];
  497.                     int g=0;
  498.                     look_tile(TILES[playerY][playerX], creatures);
  499.                     look_color(TILES[playerY][playerX], all_colors_at);
  500.                     if(GOLD[playerY][playerX]>0){   //a hack to make gold look like everything else
  501.                         g=1;
  502.                         char goldmsg[]={" 0 gold             "};
  503.                         for(int j= 0; j<names_width; j++){
  504.                             VIEW[0][j+X-names_width]=goldmsg[j];
  505.                             COLOR[0][j+X-names_width]=0;
  506.                         }
  507.                         VIEW[0][X+1-names_width]='0'+GOLD[playerY][playerX];
  508.                         COLOR[0][X+1-names_width]=color_creature(0,1);
  509.                     }
  510.                     for(int i= 0; i<Y && i<size_of_int; i++){
  511.                         for(int j= 0; j<names_width; j++){
  512.                             VIEW[i+g][j+X-names_width]=creatures[i][j];
  513.                             COLOR[i+g][j+X-names_width]=0;
  514.                         }
  515.                         COLOR[i+g][X+1-names_width]=all_colors_at[i];
  516.                     }
  517.                 }
  518.             }
  519.             attrset(COLOR_PAIR(COLOR[y][x]));
  520.             mvaddch(y, x, VIEW[y][x]);  //multiply x by 2 to get a square aspect ratio
  521. /*          mvaddch(y, x*2 +1, ' ');   */ //also uncoment this line
  522.             visible[y][x]=false;
  523.         }
  524.     }
  525.     refresh();      // refresh the screen
  526. }
  527. /***************************/
  528. void input()
  529. {
  530.     int newY=0;
  531.     int newX=0;
  532.     inchar = getch();
  533.     if(inchar != ERR)
  534.     {
  535.         if(inchar=='?' || showing_instructions){ showing_instructions=!showing_instructions;}
  536.         else if(inchar==' '){ tick(); }
  537.         else if(inchar>='0' && inchar <='9'){
  538.             if(inchar=='7' || inchar=='8' || inchar=='9'){ newY=-1; }
  539.             if(inchar=='1' || inchar=='2' || inchar=='3'){ newY=1; }
  540.             if(inchar=='7' || inchar=='4' || inchar=='1'){ newX=-1; }
  541.             if(inchar=='9' || inchar=='6' || inchar=='3'){ newX=1; }
  542.         }
  543.         put('A',ant)
  544.         put('B',bloat)
  545.         put('b',busheater)
  546.         put('c',coral)
  547.         put('D',dwarf1)
  548.         put('d',dwarf2)
  549.         put('e',sedge)
  550.         put('f',fire)
  551.         put('G',grazer)
  552.         put('g',grass)
  553.         put('j',jelly)
  554.         put('L',larva)
  555.         else if(inchar=='l'){ looking=!looking; }
  556.         put('M',lichen)
  557.         put('m',mold)
  558.         else if(inchar=='P'){
  559.             paused = !(looking || paused);
  560.             looking = false;
  561.         }
  562.         put('p',predator)
  563.         else if(inchar=='q' || inchar=='Q'){ quit=true; }
  564.         put('R',reed)
  565.         put('r',runner)
  566.         put('s',slime)
  567.         put('T',tree)
  568.         put('t',shrub)
  569.         put('V',vineroot)
  570.         put('w',sage)
  571.         else if(inchar=='x'){ xray=!xray; }
  572.         put('z',wall)
  573.         put('%',stickybush)
  574.         put('$',moss)
  575.         put('&',fireweed)
  576.         else if(inchar=='S'){
  577.             ofstream myfile;
  578.             myfile.open("dungeonsave.txt");
  579.             for(int y=0;y<Y;y++)
  580.                 for(int x=0;x<X;x++)
  581.                     myfile << TILES[y][x] << "\n";
  582.              myfile.close();
  583.         }
  584.         else if(inchar=='/'){
  585.             ifstream myfile;
  586.             myfile.open ("dungeonsave.txt");
  587.             for(int y=0;y<Y;y++)
  588.                 for(int x=0;x<X;x++)
  589.                     myfile >> TILES[y][x];
  590.              myfile.close();
  591.         }
  592.         if(legal(playerY+newY,playerX+newX)){
  593.             playerY+=newY;
  594.             playerX+=newX;
  595.         }
  596.     }
  597. }
  598. /***************************/
  599. void tick() //this advances the game one step
  600. {
  601.     if(showing_instructions){ return;}
  602.     turncount++;
  603.     int tiles[Y][X];
  604.     int subtract[Y][X];
  605.     for(int y=0; y<Y; y++){
  606.         for(int x=0; x<X; x++){
  607.                 tiles[y][x]=0;
  608.                 subtract[y][x]= ~0;
  609.         }
  610.     }
  611.     if(rand()%50==0){   //to keep things from getting stagnant it adds random things to a tile
  612.         tiles[rand()%Y][rand()%X]|=1<<(rand()%size_of_int);
  613.     }
  614.     int initialX=0,finalX=X-1,xinc;
  615.     int initialY=0,finalY=Y-1,yinc;
  616.     if(turncount%2) swap(initialY,finalY);
  617.     if(turncount%4/2) swap(initialX,finalX);
  618.     yinc=sign(finalY-initialY);
  619.     xinc=sign(finalX-initialX);
  620.     for(int y=initialY; y!=finalY+yinc; y+=yinc){
  621.         for(int x=initialX; x!=finalX+xinc; x+=xinc){ //this prevents pervasive biases towards the top
  622.             if(isAt(y,x,wall))  tiles[y][x]|=wall;
  623.             if(isAt(y,x,daisy)) tiles[y][x]|=daisy;
  624.             if(isAt(y,x,bloat)) Bloat(y,x,tiles,subtract);
  625.             if(isAt(y,x,thing1))    Thing1(y,x,tiles,subtract);
  626.             if(isAt(y,x,thing2))    Thing2(y,x,tiles,subtract);
  627.             if(isAt(y,x,reed))  Reed(y,x,tiles,subtract);
  628.             if(isAt(y,x,sedge)) Sedge(y,x,tiles,subtract);
  629.             if(isAt(y,x,coral)) Coral(y,x,tiles,subtract);
  630.             if(isAt(y,x,youngcoral))    Youngcoral(y,x,tiles,subtract);
  631.             if(isAt(y,x,plankton))  Plankton(y,x,tiles,subtract);
  632.             if(isAt(y,x,tree))  Tree(y,x,tiles,subtract);
  633.             if(isAt(y,x,sapling))   Sapling(y,x,tiles,subtract);
  634.             if(isAt(y,x,treeseed))  Treeseed(y,x,tiles,subtract);
  635.             if(isAt(y,x,shrub)) Shrub(y,x,tiles,subtract);
  636.             if(isAt(y,x,flower))    Flower(y,x,tiles,subtract);
  637.             if(isAt(y,x,sand))  tiles[y][x]|=sand;
  638.             if(isAt(y,x,door) && !isAt(y,x,wall))   tiles[y][x]|=door;
  639.             if(isAt(y,x,sage))  Sage(y,x,tiles,subtract);
  640.             if(isAt(y,x,predator))  Predator(y,x,tiles,subtract);
  641.             if(isAt(y,x,slime)) Slime(y,x,tiles,subtract);
  642.             if(isAt(y,x,grass)) Grass(y,x,tiles,subtract);
  643.             if(isAt(y,x,tallgrass)) Tallgrass(y,x,tiles,subtract);
  644.             if(isAt(y,x,jelly)) Jelly(y,x,tiles,subtract);
  645.             if(isAt(y,x,dragon))    Dragon(y,x,tiles,subtract);
  646.             if(isAt(y,x,dwarf1))    Dwarf1(y,x,tiles,subtract);
  647.             if(isAt(y,x,dwarf2))    Dwarf2(y,x,tiles,subtract);
  648.             if(isAt(y,x,fire))  Fire(y,x,tiles,subtract);
  649.             if(isAt(y,x,stickybush))    Stickybush(y,x,tiles,subtract);
  650.             if(isAt(y,x,stickyseed))    Stickyseed(y,x,tiles,subtract);
  651.             if(isAt(y,x,runner))    Runner(y,x,tiles,subtract);
  652.             if(isAt(y,x,moss))  Moss(y,x,tiles,subtract);
  653.             if(isAt(y,x,moldseed))  Moldseed(y,x,tiles,subtract);
  654.             if(isAt(y,x,mold))  Mold(y,x,tiles,subtract);
  655.             if(isAt(y,x,lichen))    Lichen(y,x,tiles,subtract);
  656.             if(isAt(y,x,fireweed))  Fireweed(y,x,tiles,subtract);
  657.             if(isAt(y,x,fireweedseed))  Fireweedseed(y,x,tiles,subtract);
  658.             if(isAt(y,x,larva)) Larva(y,x,tiles,subtract);
  659.             if(isAt(y,x,grazer))    Grazer(y,x,tiles,subtract);
  660.             if(isAt(y,x,vineroot))  Vineroot(y,x,tiles,subtract);
  661.             if(isAt(y,x,vine))  Vine(y,x,tiles,subtract);
  662.             if(isAt(y,x,ant))   Ant(y,x,tiles,subtract);
  663.             if(isAt(y,x,busheater)) Busheater(y,x,tiles,subtract);
  664.             if(GOLD[y][x]>5){
  665.                 if(notblocked(y+1,x)){GOLD[y][x]--;GOLD[y+1][x]++;}
  666.                 if(notblocked(y-1,x)){GOLD[y][x]--;GOLD[y-1][x]++;}
  667.                 if(notblocked(y,x+1)){GOLD[y][x]--;GOLD[y][x+1]++;}
  668.                 if(notblocked(y,x-1)){GOLD[y][x]--;GOLD[y][x-1]++;}
  669.             }
  670.         }
  671.     }
  672.     for(int y=0; y<Y; y++)
  673.         for(int x=0; x<X; x++){
  674.             TILES[y][x]=tiles[y][x]&subtract[y][x];
  675.             DISTURBANCE[y][x]++;
  676.             if(tiles[y][x]&fire ||tiles[y][x]&creature)
  677.                 DISTURBANCE[y][x]=0;
  678.         }
  679.     DISTURBANCE[playerY][playerX]=0;
  680. }
  681. /***************************/
  682. void Bloat(int y, int x, int tiles[Y][X],int subtract[Y][X])
  683. {
  684.     tiles[y][x]|=bloat;
  685. }
  686. /***************************/
  687. void Thing1(int y, int x, int tiles[Y][X],int subtract[Y][X])
  688. {
  689.     forOrthogonal(
  690.         if(!isAt(y+A,x+B,thing2) && notblocked(y+A,x+B) && rand()%20==0){
  691.             tiles[y+A][x+B]|=thing1;
  692.         }else if(touching(y+A,x+B,thing2)==0 && touching(y+A,x+B,thing1)<3 && rand()%10==0){
  693.             tiles[y][x]|=thing2;
  694.         }
  695.     )
  696.     if(notblocked(y,x))
  697.         tiles[y][x]|=thing1;
  698. }
  699. /***************************/
  700. void Thing2(int y, int x, int tiles[Y][X],int subtract[Y][X])
  701. {
  702.     forOrthogonal(
  703.         if(!isAt(y+A,x+B,thing1) && notblocked(y+A,x+B) && rand()%20==0 && orthogonal(y+A,x+B,thing2)<4){
  704.             tiles[y+A][x+B]|=thing2;
  705.         }
  706.     )
  707.     if(orthogonal(y,x,thing2)>3 && rand()%10==0)
  708.         tiles[y][x]|=thing1;
  709.     else if(notblocked(y,x) && (orthogonal(y,x,thing2)!=0 || orthogonal(y,x,thing1)==0) )
  710.         tiles[y][x]|=thing2;
  711. }
  712. /***************************/
  713. void Sedge(int y, int x, int tiles[Y][X],int subtract[Y][X])
  714. {
  715.     forTouching(
  716.         if(notblocked(y+A,x+B) &&rand()%15==0 && touchingNot(y+A,x+B,sedge|wall)>1){
  717.             tiles[y+A][x+B]|=sedge;
  718.         }
  719.     )
  720.     if(notblocked(y,x) && (touchingNot(y,x,sedge|wall)>0 || rand()%10))
  721.         tiles[y][x]|=sedge;
  722. }
  723. /***************************/
  724. void Coral(int y, int x, int tiles[Y][X],int subtract[Y][X])
  725. {
  726.     if(rand()%16==0){
  727.         tiles[y][x]|=plankton;
  728.     }
  729.     bool test=false;
  730.     if(rand()%100==0 && DISTURBANCE[y][x]>500){
  731.         forTouching(
  732.             if(blocked(y,x) || isAt(y,x,coral|youngcoral)){
  733.                 test=true;
  734.             }
  735.         )
  736.     }
  737.     if(test){
  738.         tiles[y][x]|=wall;
  739.     }
  740.     else if(notblocked(y,x)){
  741.         tiles[y][x]|=coral;
  742.     }
  743. }
  744. /***************************/
  745. void Youngcoral(int y, int x, int tiles[Y][X],int subtract[Y][X])
  746. {
  747.     if(rand()%500==0){
  748.         tiles[y][x]|=coral;
  749.         DISTURBANCE[y][x]=0;
  750.     }
  751.     if(notblocked(y,x)){
  752.         tiles[y][x]|=youngcoral;
  753.     }
  754. }
  755. /***************************/
  756. void Plankton(int y, int x, int tiles[Y][X],int subtract[Y][X])
  757. {
  758.     int a=0;
  759.     int b=0;
  760.     forTouching(
  761.         if(notblocked(y+A,x+B)){
  762.             a=A;
  763.             b=B;
  764.         }
  765.     )
  766.     if(rand()%50==0 && orthogonal(y,x,wall|youngcoral|coral) && !isAt(y,x,youngcoral)){
  767.         tiles[y][x]|=youngcoral;
  768.     }else if(notblocked(y,x)) {
  769.         tiles[y+a][x+b]|=plankton;
  770.     }
  771. }
  772. /***************************/
  773. void Tree(int y, int x, int tiles[Y][X],int subtract[Y][X])
  774. {
  775.     forTouching(
  776.         if(notblocked(y+A,x+B) && touching(y+A,x+B,wall)<=2 && rand()%50==0){
  777.             tiles[y+A][x+B]|=treeseed;
  778.         }
  779.         else if( touching(y+A,x+B,wall)<=2 ){ subtract[y+A][x+B]&=~wall; }
  780.     )
  781.     if(notblocked(y,x)){
  782.         tiles[y][x]|=tree;
  783. //      subtract[y][x]&= ~plant;
  784. //      subtract[y][x]|= tree;
  785.     }
  786. }
  787. /***************************/
  788. void Sapling(int y, int x, int tiles[Y][X],int subtract[Y][X])
  789. {
  790.     if(notblocked(y,x) && rand()%100==0 && touching(y,x,tree)<=1){ tiles[y][x]|=tree; }
  791.     else if(notblocked(y,x)){
  792.         tiles[y][x]|=sapling;
  793.     }
  794. }
  795. /***************************/
  796. void Treeseed(int y, int x, int tiles[Y][X],int subtract[Y][X]){
  797.     if(notblocked(y,x) && rand()%50==0 &&
  798.        (!isAt(y,x,plant) || (isAt(y,x,tallgrass)&& rand()%10==0)) && touching(y,x,tree|sapling)<3){
  799.         tiles[y][x]|=sapling;
  800.     }
  801.     else{ tiles[y][x]|=treeseed; }
  802. }
  803. /***************************/
  804. void Reed(int y, int x, int tiles[Y][X],int subtract[Y][X])
  805. {
  806.     forTouching(
  807.         if(notblocked(y+A,x+B) && (orthogonal(y+A,x+B,wall)%2==0) && touching(y+A,x+B,wall) && rand()%40==0){
  808.             tiles[y+A][x+B]|=reed;
  809.         }
  810.     )
  811.     if(notblocked(y,x) && touching(y,x,wall))
  812.         tiles[y][x]|=reed;
  813. }
  814. /***************************/
  815. void Shrub(int y, int x, int tiles[Y][X],int subtract[Y][X])
  816. {
  817.     forTouching(
  818.         if(notblocked(y+A,x+B) && (orthogonal(y+A,x+B,wall)%2==1) && rand()%20==0){
  819.             tiles[y+A][x+B]|=shrub;
  820.         }
  821.     )
  822.     if(notblocked(y,x) && touching(y,x,wall))
  823.         tiles[y][x]|=shrub;
  824. }
  825. /***************************/
  826. void Flower(int y, int x, int tiles[Y][X],int subtract[Y][X])
  827. {
  828.     forTouching(
  829.         if(notblocked(y+A,x+B) && orthogonal(y+A,x+B,flower)<=1 && touching(y+A,x+B,flower)<=3){
  830.             if(rand()%5==0){
  831.                 tiles[y+A][x+B]|=flower;
  832.             }
  833.         }
  834.     )
  835.     if(notblocked(y,x) && orthogonal(y,x,flower)<=1 && touching(y,x,flower)<=3)
  836.         tiles[y][x]|=flower;
  837. }
  838. /***************************/
  839. void Busheater(int y, int x, int tiles[Y][X],int subtract[Y][X])
  840. {
  841.     int a=0;
  842.     int b=0;
  843.     bool food=false;
  844.     if(rand()%4)
  845.         subtract[y][x]&=~bush;
  846.     forTouching(
  847.         if(notblocked(y+A,x+B) && (!food || (isAt(y+A,x+B,bush) || orthogonal(y+A,x+B,bush)))){
  848.             a=A;
  849.             b=B;
  850.             if(!food && (isAt(y+A,x+B,bush) || orthogonal(y+A,x+B,bush))){
  851.                 food=true;
  852.             }
  853.         }
  854.         if(isAt(y+A,x+B,wall) && 2>touching(y+A,x+B,wall) && rand()%2==0){
  855.             subtract[y+A][x+B]&= ~wall;
  856.         }
  857.     )
  858.     if(isAt(y,x,paralyze)){
  859.         a=0;
  860.         b=0;
  861.     }
  862.     if(isAt(y+a,x+b,bush) || rand()%1000){
  863.         tiles[y+a][x+b]|=busheater;
  864.         if(food && rand()%50==0){
  865.             tiles[y][x]|=busheater;
  866.         }
  867.         if(rand()%2){
  868.             tiles[y+a][x+b]|= (tiles[y][x]&pickupable);
  869.             subtract[y][x]&= ~pickupable;
  870.             subtract[y][x]&= ~youngcoral;
  871.         }
  872.     }
  873. }
  874. /***************************/
  875. void Ant(int y, int x, int tiles[Y][X],int subtract[Y][X])
  876. {
  877.     int a=0;
  878.     int b=0;
  879.     bool test=false;
  880.     forOrthogonal(
  881.         if( (legal(y+A,x+B) &&
  882.               isAt(y+A+2*B, x+B+2*A, wall)&& isAt(y+A-2*B, x+B-2*A, wall) &&
  883.               isAt(y+A+B, x+B+A, wall)&& isAt(y+A-B, x+B-A, wall))
  884.             || notblocked(y+A,x+B)){
  885.             a=A;
  886.             b=B;
  887.         }
  888.     )
  889.     if(isAt(y,x,paralyze)){
  890.         a=0;
  891.         b=0;
  892.     }
  893.     if(orthogonal(y,x,ant)>0 && orthogonal(y,x,wall)>=2)
  894.         forTouching( if(legal(y+A,x+B)){ subtract[y+A][x+B]&=~wall; })
  895.     tiles[y+a][x+b]|=ant;
  896.     if(rand()%2){
  897.         tiles[y+a][x+b]|= (tiles[y][x]&pickupable);
  898.         subtract[y][x]&= ~pickupable;
  899.     }
  900.     subtract[y+a][x+b]&=~wall;
  901. }
  902. /***************************/
  903. void Vine(int y, int x, int tiles[Y][X],int subtract[Y][X])
  904. {
  905.     tiles[y][x]|=livevine;
  906.     if(notblocked(y,x))
  907.         tiles[y][x]|=vine;
  908.     forTouching(
  909.         if(GOLD[y+A][x+B]>0 && !(tiles[y+A][x+B]&paralyze)&& !isAt(y+A,x+B,vineroot) && !touching(y+A,x+B,vineroot)){
  910.             GOLD[y+A][x+B]--;
  911.             GOLD[y][x]++;
  912.             tiles[y][x]|=paralyze;
  913.             subtract[y][x]&=~vine;
  914.         }
  915.         if(!isAt(y+A,x+B,vine) && isAt(y+A,x+B,livevine) && !touching(y+A,x+B,vineroot)){ //vine just died
  916.             subtract[y][x]&=~vine;
  917.         }
  918.     )
  919.     if(!isAt(y,x,fire))
  920.         forTouching(
  921.             if(notblocked(y+A,x+B) && !isAt(y+A,x+B,vineroot) && rand()%50==0)
  922.                 if(touching(y+A,x+B,(vine|vineroot))<2)
  923.                     tiles[y+A][x+B]|=vine;
  924.         )
  925. }
  926. /***************************/
  927. void Vineroot(int y, int x, int tiles[Y][X],int subtract[Y][X])
  928. {
  929.     int a=0;
  930.     int b=0;
  931.     forTouching(
  932.         if(notblocked(y+A,x+B) && rand()%10==0 &&!isAt(y+A,x+B,vineroot)&&!isAt(y+A,x+B,fire) && touching(y+A,x+B,vine)<3 )
  933.             tiles[y+A][x+B]|=vine;
  934.         if(notblocked(y+A,x+B) && GOLD[y+A][x+B]>0 && GOLD[y][x]<8 && !(tiles[y+A][x+B]&paralyze) && !isAt(y+A,x+B,vineroot) && rand()%5==0){
  935.             GOLD[y+A][x+B]--;
  936.             GOLD[y][x]++;
  937.             tiles[y+A][x+B]|=paralyze;
  938.         }
  939.         if(notblocked(y+A,x+B) && GOLD[y+A][x+B]>1 && rand()%30==0)
  940.             tiles[y+A][x+B]|=vineroot;
  941.     )
  942.     if(GOLD[y][x]>0)
  943.         tiles[y][x]|=vineroot;
  944. }
  945. /***************************/
  946. void Grazer(int y, int x, int tiles[Y][X],int subtract[Y][X])
  947. {
  948.     int a=0;
  949.     int b=0;
  950.     subtract[y][x]&=~grass;
  951.     forTouching(
  952.         if(legal(y+A,x+B) && (((isAt(y+A,x+B,tallgrass)||orthogonal(y+A,x+B,tallgrass))&& notblocked(y+A,x+B))
  953.         ||(orthogonal(y,x,wall)==3 && !koolaidman(y+A,x+B)))){
  954.             a=A;
  955.             b=B;
  956.             if(rand()%50==0)
  957.                 tiles[y][x]|=grazer;
  958.         }
  959.         if(rand()%2){
  960.             subtract[y+A][x+B]&=~tallgrass;
  961.             subtract[y+A][x+B]&=~sapling;
  962.         }
  963.     )
  964.     if(isAt(y,x,paralyze)){
  965.         a=0;
  966.         b=0;
  967.     }
  968.     if(isAt(y+a,x+b,grass) || rand()%100){
  969.         tiles[y+a][x+b]|=grazer;
  970.         if(rand()%2){
  971.             tiles[y+a][x+b]|= (tiles[y][x]&pickupable);
  972.             subtract[y][x]&= ~pickupable;
  973.         }
  974.     }
  975.     subtract[y+a][x+b]&=~wall;
  976. }
  977. /***************************/
  978. void Larva(int y, int x, int tiles[Y][X],int subtract[Y][X])
  979. {
  980.     int a=0;int b=0;
  981.     forOrthogonal(
  982.         if(legal(y+A,x+B) && (!isAt(y+A, x+B, wall) || (orthogonal(y+A,x+B,wall)>=3 &&      //either empty space or unexplored territory
  983.            legal(y+2*A+B,x+2*B+A) && isAt(y+2*A+B, x+2*B+A, wall) &&
  984.            legal(y+2*A-B,x+2*B-A) && isAt(y+2*A-B, x+2*B-A, wall)))){
  985.            a=A;
  986.            b=B;
  987.         }
  988.     )
  989.     subtract[y+a][x+b]&=~wall;
  990.     tiles[y+a][x+b]|=larva;
  991. }
  992. /***************************/
  993. void Fireweedseed(int y, int x, int tiles[Y][X],int subtract[Y][X])
  994. {
  995.     if(notblocked(y,x) && !isAt(y,x,plant) && rand()%30==0 && !touching(y,x,fireweed))
  996.         tiles[y][x]|=fireweed;
  997.     else if( notblocked(y,x) )
  998.         tiles[y][x]|=fireweedseed;
  999. }
  1000. /***************************/
  1001. void Fireweed(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1002. {
  1003.     forTouching(
  1004.         if(notblocked(y+A,x+B) && rand()%15==0 && isAt(y+A, x+B, grass))
  1005.             tiles[y+A][x+B]|=fireweedseed;
  1006.     )
  1007.     if(notblocked(y,x) && (!touching(y,x,fireweed) || rand()%15))
  1008.         tiles[y][x]|=fireweed;
  1009. }
  1010. /***************************/
  1011. void Lichen(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1012. {
  1013.     if(isAt(y,x,wall)){
  1014.         if(touching(y,x,endolithic)<6)// && (isAt(y,x,endolithic)==lichen || rand()%5))
  1015.         {
  1016.             if(!touchingNot(y,x,wall)){
  1017.                 forTouching(
  1018.                     if(rand()%15==0 && touching(y+A,x+B,endolithic)<=2 && !touchingNot(y,x,wall))
  1019.                         tiles[y+A][x+B]|=lichen;
  1020.                 )
  1021.                 tiles[y][x]|=lichen;
  1022.             }
  1023.         }
  1024.     }
  1025. }
  1026. /***************************/
  1027. void Mold(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1028. {
  1029.     forTouching(
  1030.         if(legal(y+A,x+B) && !isAt(y+A, x+B, wall) && rand()%80==0){
  1031.             tiles[y+A][x+B]|=moldseed;
  1032.         }
  1033.     )
  1034.     if(isAt(y, x, wall) && !isAt(y,x,(endolithic & ~mold)))
  1035.         tiles[y][x]|=mold;
  1036. }
  1037. /***************************/
  1038. void Moldseed(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1039. {
  1040.     bool sprout=false;
  1041.     int a=0,b=0;
  1042.     forTouching(
  1043.         if(legal(y+A,x+B) && isAt(y+A, x+B, wall)&& !isAt(y+A, x+B, endolithic) && rand()%80==0){
  1044.             sprout=true;
  1045.             a=A;
  1046.             b=B;
  1047.         }
  1048.     )
  1049.     if(sprout){ tiles[y+a][x+b]|=mold;}
  1050.     else{ tiles[y][x]|=moldseed; }
  1051. }
  1052. /***************************/
  1053. void Moss(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1054. {
  1055.     int a=0;int b=0;
  1056.     if(touchingNot(y,x,wall) && (isAt(y,x,endolithic)==moss || rand()%15)){
  1057.         forTouching(
  1058.             if(legal(y+A,x+B) && isAt(y+A, x+B, wall) && !orthogonalNot(y+A,x+B,wall) && rand()%10==0){
  1059.                 tiles[y+A][x+B]|=moss;
  1060.             }else if(orthogonalNot(y+A,x+B,wall)==1 && rand()%50==0){
  1061.                 tiles[y+A][x+B]|=wall;
  1062.             }
  1063.         )
  1064.     }
  1065.     else{
  1066.         forTouching(
  1067.             if(legal(y+A,x+B) && isAt(y+A, x+B, wall) && !isAt(y+A, x+B, endolithic)){
  1068.                 a=A;
  1069.                 b=B;
  1070.             }
  1071.         )
  1072.     }
  1073.     if(isAt(y+a, x+b, wall))
  1074.         tiles[y+a][x+b]|=moss;
  1075. }
  1076. /***************************/
  1077. void Stickyseed(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1078. {
  1079.     int a=0;
  1080.     int b=0;
  1081.     forOrthogonal(
  1082.         if(notblocked(y+A,x+B)){
  1083.             a=A;
  1084.             b=B;
  1085.         }
  1086.     )
  1087.     if(rand()%10==0 && !orthogonal(y,x,(wall|stickybush)))
  1088.         tiles[y+a][x+b]|=stickybush;
  1089.     else
  1090.         tiles[y+a][x+b]|=stickyseed;
  1091. }
  1092. /***************************/
  1093. int power(int a, int b)
  1094. {
  1095.     int c=1;
  1096.     for(int i=0;i<b;i++)
  1097.         c*=a;
  1098.     return c;
  1099. }
  1100. void Stickybush(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1101. {
  1102.     int a=0;
  1103.     int b=0;
  1104.     if(( rand() % power(50,orthogonal(y,x,(wall|stickybush)) )<1) && rand()%2){
  1105.         forOrthogonal(
  1106.             if(notblocked(y+A,x+B) && !isAt(y+A, x+B, bush)){
  1107.                 a=A;
  1108.                 b=B;
  1109.                 break;
  1110.             }
  1111.         )
  1112.     }else if(touching(y,x,(wall|stickybush)) &&rand()%20==0){   //reproduce
  1113.         tiles[y][x]|=stickyseed;
  1114.     }
  1115.     if(orthogonal(y,x,(wall|stickybush))==4 && !antikoolaidman(y,x)){
  1116.         tiles[y][x]|=wall;
  1117.     }else
  1118.         tiles[y+a][x+b]|=stickybush;
  1119. }
  1120. /***************************/
  1121. void Predator(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1122. {
  1123.     int a=0;
  1124.     int b=0;
  1125.     int best=DISTURBANCE[y][x];
  1126.     forTouching(
  1127.         if(notblocked(y+A,x+B) && DISTURBANCE[y+A][x+B]<best
  1128.             && !isAt(y+A, x+B, predator) && !(tiles[y+A][x+B]&predator)){
  1129.             a=A;
  1130.             b=B;
  1131.             best=DISTURBANCE[y+A][x+B];
  1132.         }
  1133.     )
  1134.     int worst=DISTURBANCE[y][x];
  1135.     forTouching( if(legal(y+A,x+B) && DISTURBANCE[y+A][x+B]>worst){ worst=DISTURBANCE[y+A][x+B]; } )
  1136.     if(a==0 && b==0){
  1137.         DISTURBANCE[y][x]=worst+1;
  1138.     }
  1139.     if(isAt(y+a, x+b, creature) && rand()%100==0 && legal(y-a,x-b))
  1140.         tiles[y-a][x-b]|=predator;
  1141.     subtract[y][x]&=~creature;
  1142.     if(rand()%1000)
  1143.         tiles[y+a][x+b]|=predator;
  1144.     tiles[y+a][x+b]|=paralyze;
  1145. }
  1146. /***************************/
  1147. void Runner(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1148. {
  1149.     int a=0;
  1150.     int b=0;
  1151.     int best=0;
  1152.     forTouching(
  1153.         if(legal(y+A,x+B) &&
  1154.             (   (notblocked(y+A,x+B)
  1155.             ||((isAt(y+A+1, x+B, wall)==isAt(y+A-1, x+B, wall))
  1156.             && (isAt(y+A, x+B+1, wall)==isAt(y+A, x+B-1, wall))
  1157.             && (isAt(y+A+1, x+B, wall)!=isAt(y+A, x+B-1, wall))) )
  1158.         && DISTURBANCE[y+A][x+B]>best && touching(y+A, x+B, runner)<=1 )){
  1159.             a=A;
  1160.             b=B;
  1161.             best=DISTURBANCE[y+A][x+B];
  1162.         }
  1163.         if(legal(y+A,x+B) && isAt(y+A, x+B, pickupable)){
  1164.             subtract[y+A][x+B]&= ~pickupable;
  1165.             if(rand()%400==0){
  1166.                 tiles[y][x]|=runner;
  1167.             }
  1168.     }
  1169.     )
  1170.     if(isAt(y,x,paralyze)){
  1171.         a=0;
  1172.         b=0;
  1173.     }
  1174.     if(rand()%1024)
  1175.         tiles[y+a][x+b]|=runner;
  1176.     subtract[y+a][x+b]&=~wall;
  1177. //  subtract[y][x+b]&=~wall;
  1178. //  subtract[y+a][x]&=~wall;
  1179. }
  1180. /***************************/
  1181. void Jelly(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1182. {
  1183.     int a=0;
  1184.     int b=0;
  1185.     bool food=false;
  1186.     int best=0;
  1187.     forTouching(
  1188.         if(notblocked(y+A,x+B) && orthogonal(y+A,x+B,wall) && !isAt(y+A, x+B, jelly)/* && touching(y+A,x+B,jelly)<=1 */){
  1189.             if((orthogonal(y+A,x+B,endolithic)&&(!food || DISTURBANCE[y+A][x+B]>best)) || (!food && DISTURBANCE[y+A][x+B]>best)){
  1190.                 a=A;
  1191.                 b=B;
  1192.                 best=DISTURBANCE[y+A][x+B];
  1193.                 if(orthogonal(y+A,x+B,endolithic))
  1194.                     food=true;
  1195.             }
  1196.         }
  1197.     )
  1198.     if(isAt(y,x,paralyze)){
  1199.         a=0;
  1200.         b=0;
  1201.     }
  1202.     if(touching(y,x,predator)){ tiles[y][x]|=wall;}
  1203.     if(rand()%500){
  1204.         tiles[y+a][x+b]|=jelly;
  1205.         if(rand()%2){
  1206.             tiles[y+a][x+b]|= (tiles[y][x]&pickupable);
  1207.             subtract[y][x]&= ~pickupable;
  1208.         }
  1209.     }
  1210.     for(int i=-1;i<=1;i++)
  1211.         for(int j=-1;j<=1;j++){
  1212.             if(isAt(y+i, x+j, endolithic) &&rand()%6==0){
  1213.                 if(rand()%30==0)
  1214.                     tiles[y][x]|=jelly;
  1215.                 subtract[y+i][x+j]&=~endolithic;
  1216.         }
  1217.     }
  1218. }
  1219. /***************************/
  1220. void Slime(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1221. {
  1222.     if(isAt(y,x,wall) && orthogonalNot(y,x,wall))
  1223.         tiles[y][x]|=slime;
  1224.     forTouching(
  1225.         if(touchingNot(y+A,x+B,wall) &&isAt(y+A, x+B, wall) &&rand()%10==0){ //used to be orthagonal
  1226.             tiles[y+A][x+B]|=slime;
  1227.         //}else if(orthogonal(y+A,x+B,slime)==4 && antikoolaidman(y+A,x+B)){
  1228.         //  tiles[y+A][x+B]|=wall;
  1229.         }
  1230.     )
  1231. }
  1232. /***************************/
  1233. void Sage(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1234. {
  1235.     forTouching(
  1236.         if(notblocked(y+A,x+B) && rand()%50==0 && touching(y+A,x+B,bush)<=2){ tiles[y+A][x+B]|=sage; }
  1237.     )
  1238.     if(notblocked(y,x) && (isAt(y,x,sand) || rand()%100==0)){ tiles[y][x]|=sage; }
  1239. }
  1240. /***************************/
  1241. void Fire(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1242. {
  1243.     if(isAt(y,x,burnable))
  1244.         tiles[y][x]|=fire;
  1245.     subtract[y][x]&=~burnable;
  1246.     forTouching(
  1247.         if(legal(y+A,x+B) && (isAt(y+A, x+B, flamable) || (rand()%6==0 && isAt(y+A, x+B, hardtoburn))))
  1248.             tiles[y+A][x+B]|=fire;
  1249.     )
  1250.     if(isAt(y,x,explosive))
  1251.         forOrthogonal(
  1252.             if(notblocked(y+A,x+B))
  1253.                 tiles[y+A][x+B]|=fire;
  1254.         )
  1255. }
  1256. /***************************/
  1257. void Tallgrass(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1258. {
  1259.     if(DISTURBANCE[y][x]>0 && notblocked(y,x) && !isAt(y,x,(plant & ~(grass|tallgrass))))
  1260.         tiles[y][x]|=tallgrass;
  1261.     forTouching(
  1262.         if(notblocked(y+A,x+B) && !isAt(y+A, x+B, plant) &&rand()%5==0)
  1263.             tiles[y+A][x+B]|=grass;
  1264.     )
  1265. }
  1266. /***************************/
  1267. void Grass(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1268. {
  1269.     if(rand()%50==0)
  1270.         tiles[y][x]|=tallgrass;
  1271.     if(notblocked(y,x) && !isAt(y,x,(plant & ~(grass|tallgrass))))
  1272.         tiles[y][x]|=grass;
  1273.     forOrthogonal(
  1274.         if(notblocked(y+A,x+B) && !isAt(y+A, x+B, plant) &&rand()%30==0)
  1275.             tiles[y+A][x+B]|=grass;
  1276.     )
  1277.     if(rand()%50==0 && touching(y,x,plant&(~grass)&(~tallgrass))<=0){ tiles[y][x]|=daisy; }
  1278. }
  1279. /***************************/
  1280. void Dwarf2(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1281. {
  1282.     int a=0;
  1283.     int b=0;
  1284.     forOrthogonal(
  1285.         if(legal(y+A,x+B)
  1286.             &&(!isAt(y+A, x+B, wall) /*|| !koolaidman(y+A,x+B)*/
  1287.                 ||((isAt(y+A+1, x+B, wall) != isAt(y+A-1, x+B, wall))
  1288.                     &&( isAt(y+A, x+B+1, wall) != isAt(y+A, x+B-1, wall)))
  1289.                 && !orthogonal(y+A,x+B,door))
  1290.             ){
  1291.             a=A;b=B;
  1292.         }
  1293.     )
  1294.     if(  ((isAt(y+1, x, wall) && isAt(y-1, x, wall))    //it is between two walls
  1295.         ||(isAt(y, x+1, wall) && isAt(y, x-1, wall))) &&
  1296.         !(isAt(y+1, x+1, wall)&& isAt(y+1, x-1, wall)&& //and is protecting a corner
  1297.          isAt(y-1, x+1, wall)&& isAt(y-1, x-1, wall)) )//&&
  1298.          //!touching(y-1,x-1,door))
  1299.         {
  1300.             if(rand()%4)
  1301.                 tiles[y][x]|=door;
  1302.         }
  1303.         else subtract[y][x]&=~door;
  1304.     if(isAt(y,x,paralyze)){
  1305.         a=0;
  1306.         b=0;
  1307.     }
  1308.     tiles[y+a][x+b]|=dwarf2;
  1309.     subtract[y+a][x+b] &= ~wall;
  1310.     if(GOLD[y][x]>0 && rand()%GOLD[y][x]==0){
  1311.         GOLD[y][x]--;
  1312.         GOLD[y+a][x+b]++;
  1313.     }
  1314. }
  1315. /***************************/
  1316. void Dwarf1(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1317. {
  1318.     forOrthogonal(
  1319.    
  1320.     )
  1321.  
  1322.     int A,B,a,b;
  1323.     A=B=a=b=0;
  1324.          if(isAt((y+1)%Y, x, previous)) {   A=1;    a=-1;}
  1325.     else if(isAt((y+Y-1)%Y, x, previous)){  A=-1;   a=1;}
  1326.     else if(isAt(y, (x+1)%X, previous)) {   B=1;    b=-1;}
  1327.     else if(isAt(y, (x+X-1)%X, previous)){  B=-1;   b=1;}
  1328.     else{
  1329.         if(rand()%2) a=rand()%2*2-1;
  1330.         else b=rand()%2*2-1;
  1331.     }
  1332.     if(!supersuperlegal(y+a,x+b))
  1333.         if(rand()%2) {a=rand()%2*2-1;b=0;}
  1334.         else {b=rand()%2*2-1;a=0;}
  1335.     if(b!=0){
  1336.         if(GOLD[(y+1)%Y][x]>0)      {   a=1;    b=0;}
  1337.         else if(GOLD[(y+Y-1)%Y][x]>0){  a=-1;   b=0;}
  1338.     }
  1339.     else{
  1340.         if(GOLD[y][(x+1)%X]>0)      {   b=1;    a=0;}
  1341.         else if(GOLD[y][(x+X-1)%X]>0){  b=-1;   a=0;}
  1342.     }
  1343.     if(isAt(y,x,paralyze)){
  1344.         a=0;
  1345.         b=0;
  1346.     }
  1347. /*  if(rand()%15){
  1348.         tiles[y][x]|=dwarf1;
  1349.         tiles[y+A][x+B]|=previous;
  1350.     }else
  1351. */  {
  1352.         if(!superlegal(y+a,x+b)){a=0; b=0;}
  1353.         if(GOLD[y][x]>0){
  1354.             if(GOLD[y][x]>4 && rand()%3==0){
  1355.                 subtract[y][x]&=(~wall);
  1356.                 tiles[y][x]|=dragon;
  1357.                 tiles[y][x]|=vineroot;
  1358.                 return;
  1359.             }
  1360.             if(rand()%GOLD[y][x]==0){
  1361.                 GOLD[y][x]--;
  1362.                 GOLD[y+a][x+b]++;
  1363.             }
  1364.             else
  1365.                 tiles[y][x]|=dwarf2;
  1366.         }
  1367.         subtract[y][x] &= ~wall;
  1368.         //if(rand()%50 || 2<orthogonal(y,x,wall)){
  1369.             tiles[y+a][x+b]|=dwarf1;
  1370.             tiles[y][x]|=previous;
  1371.         //}
  1372.     }
  1373. }
  1374. /***************************/
  1375. void Dragon(int y, int x, int tiles[Y][X],int subtract[Y][X])
  1376. {
  1377.     int a,b;
  1378.     a=b=0;
  1379.     bool test=false;
  1380.     if(!isAt(y,x,paralyze))
  1381.         forTouching(
  1382.             if(notblocked(y+A,x+B) && (rand()%15==0 || !test || GOLD[y+A][x+B]>0)){
  1383.                 a=A;
  1384.                 b=B;
  1385.                 test=true;
  1386.             }
  1387.         )
  1388. /*  if(GOLD[y][x]==0 && max(abs(playerY-y),abs(playerX-x))<10){
  1389.         int A=sign(playerY-y);
  1390.         int B=sign(playerX-x);
  1391.         if(notblocked(y+A,x+B)){
  1392.             a=A;
  1393.             b=B;
  1394.         }
  1395.     }
  1396. */  if(GOLD[y][x]>0 && rand()%GOLD[y][x]==0){
  1397.         GOLD[y][x]--;
  1398.         GOLD[y+a][x+b]++;
  1399.     }
  1400. //  if(max(abs(playerY-y),abs(playerX-x))<5 && rand()%5==0)
  1401. //      tiles[y+a][x+b]|=fire;
  1402.     if(rand()%100 || GOLD[y+a][x+a]>2){
  1403.         tiles[y+a][x+b]|=dragon;
  1404.     }
  1405. }
  1406. /***************************/
  1407. int touchingNot(int y, int x, int item)
  1408. {
  1409.     int count=0;
  1410.     for(int a=-1;a<=1;a++)
  1411.         for(int b=-1;b<=1;b++)
  1412.             if((a!=0 || b!=0) && legal(y+a,x+b) && !isAt(y+a, x+b, item))
  1413.                 count++;
  1414.     return count;
  1415. }
  1416. int touching(int y, int x, int item)
  1417. {
  1418.     int count=0;
  1419.     for(int a=-1;a<=1;a++)
  1420.         for(int b=-1;b<=1;b++)
  1421.             if((a!=0 || b!=0) && legal(y+a,x+b) && isAt(y+a, x+b, item))
  1422.                 count++;
  1423.     return count;
  1424. }
  1425. int diagonalNot(int y, int x, int item)
  1426. {
  1427.     int count=0;
  1428.     int xdir[]={-1,-1,1,1};
  1429.     int ydir[]={1,-1,1,-1};
  1430.     for(int i=0;i<4;i++)
  1431.         if(legal(y+xdir[i],x+ydir[i]) && !isAt(y+xdir[i], x+ydir[i], item))
  1432.             count++;
  1433.     return count;
  1434. }
  1435. int diagonal(int y, int x, int item)
  1436. {
  1437.     int count=0;
  1438.     int xdir[]={-1,-1,1,1};
  1439.     int ydir[]={1,-1,1,-1};
  1440.     for(int i=0;i<4;i++)
  1441.         if(legal(y+ydir[i],x+xdir[i]) && isAt(y+ydir[i], x+xdir[i], item))
  1442.             count++;
  1443.     return count;
  1444. }
  1445. int orthogonalNot(int y, int x, int item)
  1446. {
  1447.     int count=0;
  1448.     int xdir[]={-1,0,1,0};
  1449.     int ydir[]={0,-1,0,1};
  1450.     for(int i=0;i<4;i++)
  1451.         if(legal(y+xdir[i],x+ydir[i]) && !isAt(y+xdir[i], x+ydir[i], item))
  1452.             count++;
  1453.     return count;
  1454. }
  1455. int orthogonal(int y, int x, int item)
  1456. {
  1457.     int count=0;
  1458.     int ydir[]={-1,0,1,0};
  1459.     int xdir[]={0,-1,0,1};
  1460.     for(int i=0;i<4;i++)
  1461.         if(legal(y+ydir[i],x+xdir[i]) && isAt(y+ydir[i], x+xdir[i], item))
  1462.             count++;
  1463.     return count;
  1464. }
  1465. bool antikoolaidman(int y, int x)
  1466. {
  1467.     if(blocked(y,x))
  1468.         return false;
  1469.     int ydir[]={-1,-1,1,1};
  1470.     int xdir[]={-1,1,-1,1};
  1471.     for(int i=0;i<4;i++){
  1472.         if(notblocked(y+ydir[i],x+xdir[i]) &&
  1473.         (notblocked(y,x-xdir[i])||notblocked(y-ydir[i],x-xdir[i])||notblocked(y-ydir[i],x)) &&
  1474.         !notblocked(y,x+xdir[i]) && !notblocked(y+ydir[i],x))
  1475.             return true;
  1476.     }
  1477.     if(!notblocked(y+1,x)  && !notblocked(y-1,x)    &&
  1478.     ((notblocked(y,x+1)   && notblocked(y,x-1))     ||
  1479.      (notblocked(y+1,x+1) && notblocked(y+1,x-1))   ||
  1480.      (notblocked(y-1,x+1) && notblocked(y-1,x-1))))
  1481.         return true;
  1482.     if(!notblocked(y,x+1)  && !notblocked(y,x-1)    &&
  1483.     ((notblocked(y+1,x)   && notblocked(y-1,x))     ||
  1484.      (notblocked(y+1,x+1) && notblocked(y-1,x+1))   ||
  1485.      (notblocked(y+1,x-1) && notblocked(y-1,x-1))))
  1486.         return true;
  1487.     return false;
  1488. }
  1489. bool koolaidman(int y, int x)
  1490. {
  1491.     if(notblocked(y,x))
  1492.         return false;
  1493.     int ydir[]={-1,-1,1,1};
  1494.     int xdir[]={-1,1,-1,1};
  1495.     for(int i=0;i<4;i++){
  1496.         if(notblocked(y+ydir[i],x+xdir[i]) &&
  1497.         (notblocked(y,x-xdir[i])||notblocked(y-ydir[i],x-xdir[i])||notblocked(y-ydir[i],x)) &&
  1498.         blocked(y,x+xdir[i]) && blocked(y+ydir[i],x))
  1499.             return true;
  1500.     }
  1501.     if(blocked(y+1,x)  && blocked(y-1,x)    &&
  1502.     ((notblocked(y,x+1)   && notblocked(y,x-1))     ||
  1503.      (notblocked(y+1,x+1) && notblocked(y+1,x-1))   ||
  1504.      (notblocked(y-1,x+1) && notblocked(y-1,x-1))))
  1505.         return true;
  1506.     if(blocked(y,x+1)  && blocked(y,x-1)    &&
  1507.     ((notblocked(y+1,x)   && notblocked(y-1,x))     ||
  1508.      (notblocked(y+1,x+1) && notblocked(y-1,x+1))   ||
  1509.      (notblocked(y+1,x-1) && notblocked(y-1,x-1))))
  1510.         return true;
  1511.     return false;
  1512. }
  1513. bool nocorner(int y, int x)
  1514. {
  1515.     if(!isAt(y,x,wall))
  1516.         return true;
  1517.     forDiagonal(
  1518.         if(!isAt(y+A, x+B, wall) &&isAt(y, x+B, wall) &&isAt(y+A, x, wall))
  1519.             return false;
  1520.     )
  1521.     return true;
  1522. }
  1523. /***************************/
  1524. void swap(int &a,int &b)
  1525. {
  1526.     int temp=a;
  1527.     a=b;
  1528.     b=temp;
  1529. }
  1530. bool bresenham(int y0,int y1,int x0,int x1)
  1531. {
  1532.     bool steep = abs(y1 - y0) > abs(x1 - x0);
  1533.     if(steep)
  1534.     {
  1535.         swap(x0, y0);
  1536.         swap(x1, y1);
  1537.     }
  1538.     int ystep=1;
  1539.     if (y0 > y1)    ystep = -1;
  1540.     int dir=1;
  1541.     if(x0 > x1)     dir = -1;
  1542.     int deltay = abs(y1 - y0);
  1543.     int deltax = dir*(x1 - x0);
  1544.     int error = deltax / 2;
  1545.     int y = y0;
  1546.     for(int x=x0; x!=x1; x+=dir)
  1547.     {
  1548.         if(steep && legal(x,y))
  1549.         {
  1550.             visible[x][y]=true;
  1551.             if(isAt(x,y,wall))
  1552.                 return false;
  1553.         }
  1554.         else if(legal(y,x))
  1555.         {
  1556.             visible[y][x]=true;
  1557.             if(isAt(y,x,wall))
  1558.                 return false;
  1559.         }
  1560.         error -= deltay;
  1561.         if(error < 0)
  1562.         {
  1563.             y += ystep;
  1564.             error += deltax;
  1565.         }
  1566.     }
  1567.     return true;
  1568. }
  1569. /***************************/
  1570. void shuffle(int arry[],int length)
  1571. {
  1572.     for(int k,j,i=0;i<length;i++){
  1573.         j=i+rand()%(length-i);
  1574.         swap(arry[j],arry[i]);
  1575.     }
  1576. }/***************************/
  1577. int sign(int a)
  1578. {
  1579.     return (a>0)-(a<0);
  1580. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!