viseq/src/connection-manager.h

#pragma once

#include "connection.h"
#include "node-manager.h"
#include "raylib.h"
#include "raymath.h"
#include <map>
#include <vector>

class ConnectionManager{

	public:

		ConnectionManager(NodeManager *nm) : nm(nm) {}

		NodeManager *nm;

		std::vector<Connection> connections;

		std::map<int, int> counter;

		void reset(){
			counter.clear();
		}

		int next(int current, int last){
			std::vector<Connection*> possible_connections;
			std::vector<int> next_node_ids;

			for(auto& c : connections){
				if((c.v1 == current && c.v1_v2) || (c.v2 == current && c.v2_v1)) {
					c.active = false;
					possible_connections.push_back(&c);
					next_node_ids.push_back( c.v1 == current ? c.v2 : c.v1 );
				}
			}
		
			/*if(possible_connections.size() == 2) {*/
			/*	int next = next_node_ids[0] == last ? next_node_ids[1] : next_node_ids[0];*/
			/*	if(possible_connections[0]->v1 == next || possible_connections[0]->v2 == next) possible_connections[0]->active = true;*/
			/*	if(possible_connections[1]->v1 == next || possible_connections[1]->v2 == next) possible_connections[1]->active = true;*/
			/*	return next;*/
			/*}*/

			if(possible_connections.empty()) return -1;
			
			int return_path = 0;
			float angle = -1;
			if(nm->nodes.at(current).distributionMode == Distribution::GEOMETRIC){
				Vec2D<float> coming_from = (nm->nodes.at(current).position - nm->nodes.at(last).position).norm();
				int i = 0;
				for(auto n : possible_connections){
					int next_position = n->v1 == current ? n->v2 : n->v1;
					float angle_v1_v2 = coming_from.norm().dot((nm->nodes.at(next_position).position - nm->nodes.at(current).position).norm());
					if(angle_v1_v2 > angle) {
						return_path = i;
						angle = angle_v1_v2;
					}
					++i;
				}
			}

			if(nm->nodes.at(current).distributionMode == Distribution::ROUNDROBIN){
				if(counter.find(current) == counter.end()) {
					counter[current] = 0;
				} else {
					counter[current] = (counter[current] + 1) % possible_connections.size();
					return_path = counter[current];
				}
			}
			
			if(nm->nodes.at(current).distributionMode == Distribution::RANDOM){
				return_path = rand() % possible_connections.size();
			}
			
			possible_connections.at(return_path)->active = true;
			return possible_connections.at(return_path)->v1 == current ? possible_connections.at(return_path)->v2 : possible_connections.at(return_path)->v1;
		}

		void addConnection(int from, int to){
			connections.emplace_back(&nm->nodes, from, to);
		}

		void drawConnections(Vec2D<float> *mouse_pos, Camera2D *cam){
			std::erase_if(connections, [](Connection c){ return c.remove == true;});
			for(auto& c : connections){
				c.draw(mouse_pos, cam);
			}
		}
};