Add files via upload

Author: SzymokArch

cellular_automata/cellular_automata.c

@@ -0,0 +1,72 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include "cellular_automata.h"
+
+bool is_within_map_bounds(int y, int x, bool ** map, int size){
+  if (y < 0 || x < 0 || y >= size || x >= size){
+    return false;
+  }
+  return true;
+}
+
+void copy_bool_map(bool ** dest, bool ** src, int size){
+  for (int i = 0; i < size; i ++){
+    for (int j = 0; j < size; j ++){
+      dest[i][j] = src[i][j];
+    }
+  }
+}
+
+void cellular_automata(bool ** map, int size, int iterations){
+  int f_count;
+  bool ** temp_map = (bool **)calloc(size, sizeof(bool *));
+  for (int i = 0; i < size; i ++){
+    temp_map[i] = (bool *)calloc(size, sizeof(bool));
+  }
+
+  for (int i = 0; i < iterations; i ++){
+    copy_bool_map(temp_map, map, size);
+    for (int j = 0; j < size; j ++){
+      for (int k = 0; k < size; k ++){
+        f_count = 0;
+        for (int y = j - 1; y <= j + 1; y ++){
+          for (int x = k - 1; x <= k + 1; x ++){
+            if (is_within_map_bounds(y, x, map, size)){
+              if (y != j || x != k){
+                if (!temp_map[y][x]){
+                  f_count ++;
+                }
+              }
+            }
+            else {
+              f_count ++;
+            }
+          }
+        }
+        if (f_count > 4){
+          map[j][k] = 0;
+        }
+        else {
+          map[j][k] = 1;
+        }
+      }
+    }
+  }
+  for (int i = 0; i < size; i ++){
+    free(temp_map[i]);
+  }
+  free(temp_map);
+}
+
+bool ** generate_cellular_automata(int seed, int density, int size, int iterations){
+  srand(seed);
+  bool ** map = (bool **)calloc(size, sizeof(bool *));
+  for (int i = 0; i < size; i ++){
+    map[i] = (bool *)calloc(size, sizeof(bool));
+    for (int j = 0; j < size; j ++){
+      map[i][j] = rand()%101 > density;
+    }
+  }
+  cellular_automata(map, size, iterations);
+  return map;
+}

cellular_automata/cellular_automata.h

@@ -0,0 +1,11 @@
+#include <stdbool.h>
+
+#ifndef CELLULAR_AUTOMATA_H
+#define CELLULAR_AUTOMATA_H
+
+bool is_within_map_bounds(int, int, bool **, int);
+void copy_bool_map(bool **, bool **, int);
+void cellular_automata(bool **, int, int);
+bool ** generate_cellular_automata(int, int, int, int);
+
+#endif // !CELLULAR_AUTOMATA_H

value_noise/value_noise.c

@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <math.h>
+#include "value_noise.h"
+
+// returns a value between a and b
+// x is a floating point number between 0 and 1
+// x = 0 returns a and x = 1 returns b
+float interpolation_cosine(float a, float b, float x){
+  float ft = x * M_PI;
+  float f = (1 - cos(ft)) * .5;
+
+  return a * (1 - f) + b * f;
+}
+
+// function for initializing a square consisting of points gained by interpolating between the (known) corner values
+// uses the method for bilinear interpolation but with cosine interpolation instead of linear interpolation
+// initializes values on 2 axes (every vertical value for start_x and end_x) and interpolates between them
+void interpolation_2D(float ** map, int start_y, int start_x, int end_y, int end_x){
+  for (int i = start_y; i <= end_y; i ++){
+    map[i][start_x] = interpolation_cosine(map[start_y][start_x], map[end_y][start_x], (double)(i - start_y)/(end_y - start_y));
+    map[i][end_x] = interpolation_cosine(map[start_y][end_x], map[end_y][end_x], (double)(i - start_y)/(end_y - start_y));
+    for (int j = start_x; j <= end_x; j ++){
+      map[i][j] = interpolation_cosine(map[i][start_x], map[i][end_x], (double)(j - start_x)/(end_x - start_x));
+    }
+  }
+}
+
+// sometimes some values in the final generated noise map may be greater than one
+// we don't want that, since it makes the map quite inconvenient to display
+// this functions takes the generated noise map and normalises the values
+// the biggest value found in the map is set to 1 and the smallest to 0
+// all other values are asigned accordingly
+void normalize_noise(float ** map, int size){
+  float maxi = map[0][0];
+  float mini = map[0][0];
+  for (int i = 0; i < size; i ++){
+    for (int j = 0; j < size; j ++){
+      if (map[i][j] > maxi){
+        maxi = map[i][j];
+      }
+      if (map[i][j] < mini){
+        mini = map[i][j];
+      }
+    }
+  }
+  float dif = maxi - mini;
+  for (int i = 0; i < size; i ++){
+    for (int j = 0; j < size; j ++){
+      map[i][j] = (map[i][j] - mini)/dif;
+    }
+  }
+}
+
+// initializes the value noise 2D array
+float ** value_noise(float ** noise_map, int size, int octaves, double scaling_factor){
+  float ** gen_map = (float **)calloc(size, sizeof(float *));
+  for (int i = 0; i < size; i ++){
+    gen_map[i] = (float *)calloc(size, sizeof(float));
+  }
+
+  int pitch;
+  double persistance = 1;
+
+  for (int o = 0; o <= octaves; o ++){
+    pitch = (int)(size - 1)/pow(2, o);
+    for (int i = 0; i < size; i += pitch){
+      for (int j = 0; j < size; j += pitch){
+        gen_map[i][j] += noise_map[i][j] * persistance;
+      }
+    }
+    for (int i = 0; i < size - pitch; i += pitch){
+      for (int j = 0; j < size - pitch; j += pitch){
+        interpolation_2D(gen_map, i, j, i + pitch, j + pitch);
+      }
+    }
+    persistance /= scaling_factor;
+  }
+  normalize_noise(gen_map, size);
+  return gen_map;
+}
+
+// generates a square 2D value noise array (the array size has to be equal to 2^n + 1 and the octave count must be <= n)
+// couldn't be bothered to implement error handling, so for the love of God input the right values!
+float ** generate_value_noise(int seed, int size, int octaves, double scaling_factor){
+  srand(seed);
+  float ** nmap = (float **)calloc(size, sizeof(float *));
+  for (int i = 0; i < size; i ++){
+    nmap[i] = (float *)calloc(size, sizeof(float));
+    for (int j = 0; j < size; j ++){
+      nmap[i][j] = rand()%10001/1000.;
+    }
+  }
+  float ** gmap = value_noise(nmap, size, octaves, scaling_factor);
+  for (int i = 0; i < size; i ++){
+    free(nmap[i]);
+  }
+  free(nmap);
+
+  return gmap;
+}

value_noise/value_noise.h

@@ -0,0 +1,10 @@
+#ifndef VALUE_NOISE_H
+#define VALUE_NOISE_H
+
+float interpolation_cosine(float, float, float);
+void interpolation_2D(float **, int, int, int, int);
+void normalize_noise(float **, int);
+float ** value_noise(float **, int, int, double);
+float ** generate_value_noise(int, int, int, double);
+
+#endif // !VALUE_NOISE_H

voronoi/voronoi.c

@@ -0,0 +1,98 @@
+#include <stdlib.h>
+#include <math.h>
+#include <stdbool.h>
+#include "voronoi.h"
+
+float minkowski_distance(int ay, int ax, int by, int bx, int p){
+  switch (p){
+    case 1:
+      return abs(by - ay) + abs(bx - ax);
+    case 2:
+      return sqrt(pow(by - ay, 2) + pow(bx - ax, 2));
+    default:
+      return pow(pow(abs(ay - by), p) + pow(abs(ax - bx), p), 1./p);
+  }
+}
+
+site get_center(int start_y, int start_x, int pitch){
+  site result;
+  result.y = abs(2 * start_y + pitch) / 2;
+  result.x = abs(2 * start_x + pitch) / 2;
+  return result;
+}
+
+site * get_center_array(int size, int divisions){
+  site * center_array = (site *)calloc(pow(4, divisions), sizeof(site));
+  int pitch = (size - 1)/pow(2, divisions);
+  int index = 0;
+  for (int i = 0; i < size - pitch; i += pitch){
+    for (int j = 0; j < size - pitch; j += pitch){
+      center_array[index].y = (2 * i + pitch)/2;
+      center_array[index].x = (2 * j + pitch)/2;
+      index ++;
+    }
+  }
+  return center_array;
+}
+
+void move_centers(int seed, site * center_array, int center_quantity){
+  srand(seed);
+  bool movement_down;
+  bool movement_right;
+  int max_movement = center_array[0].x;
+  for (int i = 0; i < center_quantity; i ++){
+    movement_down = rand()%101 > 50;
+    movement_right = rand()%101 > 50;
+    if (movement_down){
+      center_array[i].y += rand()%max_movement;
+    }
+    else{
+      center_array[i].y -= rand()%max_movement;
+    }
+    if (movement_right){
+      center_array[i].x += rand()%max_movement;
+    }
+    else{
+      center_array[i].x -= rand()%max_movement;
+    }
+  }
+}
+
+short get_closest_site(int y, int x, site * sites, int site_quantity, int p){
+  float min;
+  short index;
+  float * distances = (float *)calloc(site_quantity, sizeof(float));
+  min = minkowski_distance(y, x, sites[0].y, sites[0].x, p);
+  index = 0;
+  for (int i = 0; i < site_quantity; i++){
+    distances[i] = minkowski_distance(y, x, sites[i].y, sites[i].x, p);
+    if (distances[i] < min){
+      min = distances[i];
+      index = i;
+    }
+  }
+  return index;
+}
+
+void voronoi_diagram(short ** map, int size, site * sites, int site_quantity, int p){
+  for (int i = 0; i < size; i ++){
+    for (int j = 0; j < size; j ++){
+      map[i][j] = get_closest_site(j, i, sites, site_quantity, p);
+    }
+  }
+}
+
+short ** generate_voronoi_diagram(int seed, int size, int divisions, int p){
+  srand(seed);
+  short ** map = (short **)calloc(size, sizeof(short *));
+  for (int i = 0; i < size; i ++){
+    map[i] = (short *)calloc(size, sizeof(short));
+  }
+  site * centarr = get_center_array(size, divisions);
+  int cent_q = pow(4, divisions);
+  move_centers(seed, centarr, cent_q);
+  voronoi_diagram(map, size, centarr, cent_q, p);
+
+  free(centarr);
+  return map;
+}

voronoi/voronoi.h

@@ -0,0 +1,16 @@
+#ifndef VORONOI_H
+#define VORONOI_H
+
+typedef struct site{
+  int y;
+  int x;
+} site;
+
+site get_center(int, int, int);
+site * get_center_array(int, int);
+void move_centers(int, site *, int);
+short get_closes_site(int, int, site *, int, int);
+void voronoi_diagram(short **, int, site *, int, int);
+short ** generate_voronoi_diagram(int, int, int, int);
+
+#endif // !VORONOI_H