Initial commit

Signed-off-by: Aiden Woodruff <aiden.woodruff@gmail.com>

8 files changed, 307 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..567609b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+build/
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..37b4227
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.8)
+project(idkproject VERSION 0 LANGUAGES CXX)
+
+find_package(SFML 2 REQUIRED COMPONENTS graphics)
+
+add_executable(main main.cc)
+target_compile_options(main PUBLIC -g)
+target_link_libraries(main PRIVATE sfml-graphics)
+target_compile_features(main PRIVATE cxx_auto_type cxx_range_for)
\ No newline at end of file
diff --git a/ConstellationApp.h b/ConstellationApp.h
new file mode 100644
index 0000000..5fa9ce0
--- /dev/null
+++ b/ConstellationApp.h
@@ -0,0 +1,36 @@
+#include "ConstellationModel.h"
+#include "ConstellationView.h"
+#include "ConstellationController.h"
+
+namespace Constellation {
+class App {
+  Model m;
+  View v;
+  Controller c;
+  int screenwidth, screenheight;
+
+  public:
+    /**
+     * @brief Construct a new App object.
+     * 
+     * @param sw Screen width.
+     * @param sh Screen height.
+     * @param sr Star radius. 
+     * @param n Star count.
+     * @param minc Minimum constellation number.
+     */
+    App(int sw, int sh, int sr, int n, int minc):
+      m(n, minc, sw, sh, sr), v(sw, sh, sr), c(&m, &v) {}
+    
+    void run() {
+      v.make_window();
+      while (c.isRunning()) {
+        c.collect_input();
+        c.advance_state();
+        v.display();
+        sf::sleep(sf::milliseconds(1));
+      }
+      v.close_window();
+    }
+};
+}
diff --git a/ConstellationController.h b/ConstellationController.h
new file mode 100644
index 0000000..24b5328
--- /dev/null
+++ b/ConstellationController.h
@@ -0,0 +1,81 @@
+#include "ConstellationModel.h"
+#include "ConstellationView.h"
+
+#include <SFML/System.hpp>
+
+#ifndef CONSTELLATION_CONTROLLER_H_
+#define CONSTELLATION_CONTROLLER_H_
+
+namespace Constellation {
+  class Controller {
+    Model *model;
+    View *view;
+    bool running;
+
+    enum class Mode : int {
+      idle = 0,
+      stars,
+      edges
+    } mode;
+
+    Model::EdgeIterator eIt;
+    Model::VertexIterator vIt;
+    
+    public:
+    Controller(Model *m, View *v) : model(m), view(v), running(true),
+    mode(Mode::idle) {}
+
+    bool isRunning() const { return running; }
+
+    void collect_input() {
+      sf::Event event;
+      while (view->window->pollEvent(event)) {
+        if (event.type == sf::Event::Closed) {
+          running = false;
+        } else if (mode == Mode::idle) {
+          if (event.type == sf::Event::KeyReleased) {
+            if (event.key.code == sf::Keyboard::R) {
+              mode = Mode::stars;
+              model->randomize_stars();
+              view->clear_stars();
+              view->clear_edges();
+              vIt = model->vbegin();
+            } else if (event.key.code == sf::Keyboard::G) {
+              mode = Mode::edges;
+              model->generate_edges();
+              view->clear_edges();
+              eIt = model->ebegin();
+            }
+          }
+        }
+      }
+    }
+
+    void advance_state() {
+      switch (mode) {
+        case Mode::stars:
+          if (vIt != model->vend()) {
+            view->add_star(*vIt);
+            ++vIt;
+          } else {
+            mode = Mode::idle;
+          }
+          break;
+        case Mode::edges:
+          if (eIt != model->eend()) {
+            std::pair<sf::Vector2f,sf::Vector2f> e = model->edge_data(*eIt);
+            view->add_edge(sf::Vertex(e.first), sf::Vertex(e.second));
+            ++eIt;
+          } else {
+            mode = Mode::idle;
+          }
+          break;
+        case Mode::idle:
+        default:
+          break;
+      }
+    }
+  };
+} // namespace Constellation
+
+#endif // CONSTELLATION_CONTROLLER_H_
diff --git a/ConstellationModel.h b/ConstellationModel.h
new file mode 100644
index 0000000..44b1b32
--- /dev/null
+++ b/ConstellationModel.h
@@ -0,0 +1,98 @@
+#include <random>
+#include <vector>
+#include <utility>
+#include <iostream>
+
+#include <SFML/System.hpp>
+
+#ifndef CONSTELLATION_MODEL_H_
+#define CONSTELLATION_MODEL_H_
+
+namespace Constellation {
+  class Model {
+    using Edge = std::pair<int, int>;
+
+    int stars, min_constellations;
+    std::mt19937 engine;
+    std::uniform_int_distribution<int> x_dist, y_dist;
+    std::vector<sf::Vector2f> vertices;
+    std::vector<Edge> edges;
+    public:
+      Model(int n, int minc, int sw, int sh, int sr) :
+        stars(n), min_constellations(minc),
+        x_dist(sr, sw - sr), y_dist(sr, sh - sr) {
+        engine = std::mt19937(std::random_device{}());
+      }
+      using EdgeIterator = std::vector<Edge>::const_iterator;
+      using VertexIterator = std::vector<sf::Vector2f>::const_iterator;
+
+      EdgeIterator ebegin() const { return edges.cbegin(); }
+      EdgeIterator eend() const { return edges.cend(); }
+      VertexIterator vbegin() const { return vertices.cbegin(); }
+      VertexIterator vend() const { return vertices.cend(); }
+
+
+      std::pair<sf::Vector2f, sf::Vector2f> edge_data(const Edge& e) {
+        return {vertices[e.first], vertices[e.second]};
+      }
+
+      void randomize_stars () {
+        vertices.clear();
+        edges.clear();
+        for (int i = 0; i < stars; ++i) {
+          float x = x_dist(engine), y = y_dist(engine);
+          vertices.push_back({x, y});
+        }
+      }
+
+      private:
+      float distance (int u, int v) {
+        float xdiff = vertices[v].x - vertices[u].x,
+              ydiff = vertices[v].y - vertices[u].y;
+        return xdiff * xdiff + ydiff * ydiff;
+      }
+      public:
+      void generate_edges() {
+        if (vertices.empty()) return;
+        edges.clear();
+
+        // Generate all possible edges.
+        std::vector<std::pair<float, Edge>> possible_edges;
+        possible_edges.reserve(stars * stars);
+        for (int i = 0; i < stars; ++i) {
+          for (int j = 0; j < stars; ++j) {
+            if (i != j)
+              possible_edges.push_back({distance(i, j), {i, j}});
+          }
+        }
+        // Sort in order of min distance.
+        std::sort(possible_edges.begin(), possible_edges.end());
+
+        std::vector<std::vector<int>> v_sets(stars); // Sets of vertices.
+        std::vector<int> v_s(stars, -1); // Owning set of each vertex.
+        for (int i = 0; i < stars; ++i) {
+          v_sets[i].push_back(i);
+          v_s[i] = i;
+        }
+
+        // Loop through min edges and and connect disconnected components.
+        for (int p = 0, c = stars ; p < possible_edges.size() &&
+                                    c > min_constellations; ++p) {
+          const Edge& e = possible_edges[p].second;
+          if (v_s[e.first] != v_s[e.second]) {
+            edges.push_back(e);
+            int V = v_s[e.first], U = v_s[e.second];
+            for (int i = 0; i < v_sets[U].size(); ++i) {
+              int u = v_sets[U][i];
+              v_s[u] = V;
+              v_sets[V].push_back(u);
+            }
+            v_sets[U].clear();
+            c--;
+          }
+        }
+      }
+  };
+} // namespace Constellation
+
+#endif // CONSTELLATION_MODEL_H_
diff --git a/ConstellationView.h b/ConstellationView.h
new file mode 100644
index 0000000..491afe3
--- /dev/null
+++ b/ConstellationView.h
@@ -0,0 +1,72 @@
+#include <iostream>
+#include <vector>
+
+#include <SFML/Graphics.hpp>
+
+#ifndef CONSTELLATION_VIEW_H_
+#define CONSTELLATION_VIEW_H_
+
+namespace Constellation {
+  class View {
+    int width, height, star_radius;
+    sf::RenderWindow *window;
+    std::vector<sf::Vector2f> starPos;
+    sf::VertexArray edges;
+    sf::CircleShape star;
+    public:
+    View(int w, int h, int sr) : width(w), height(h), star_radius(sr),
+      window(nullptr), star(star_radius), edges(sf::Lines) {
+        star.setOrigin(star_radius, star_radius);
+    }
+
+    ~View() {
+      if (window) {
+        delete window;
+      }
+    }
+
+    void make_window () {
+      if (!window) {
+        window = new sf::RenderWindow(sf::VideoMode(width, height), "Constellations");
+      }
+    }
+
+    void close_window () {
+      window->close();
+    }
+
+    void add_star(const sf::Vector2f& v) {
+      starPos.push_back(v);
+    }
+
+    void clear_stars() {
+      starPos.clear();
+    }
+
+    void add_edge(const sf::Vertex& v, const sf::Vertex& u) {
+      edges.append(v);
+      edges.append(u);
+    }
+
+    void clear_edges() {
+      edges.clear();
+    }
+
+    void print_done() {
+      std::cout << "Done." << std::endl;
+    }
+
+    void display() {
+      window->clear();
+      window->draw(edges);
+      for (const sf::Vector2f& p : starPos) {
+        star.setPosition(p);
+        window->draw(star);
+      }
+      window->display();
+    }
+
+    friend class Controller;
+  };
+} // namespace Constellation
+#endif // CONSTELLATION_VIEW_H_
diff --git a/config.sh b/config.sh
new file mode 100644
index 0000000..58c7d2c
--- /dev/null
+++ b/config.sh
@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+
+cmake -S . -B build
diff --git a/main.cc b/main.cc
new file mode 100644
index 0000000..f0c5fb6
--- /dev/null
+++ b/main.cc
@@ -0,0 +1,7 @@
+#include "ConstellationApp.h"
+
+int main () {
+  Constellation::App app(1200, 675, 3, 400, 10);
+  app.run();
+  return 0;
+}