almost done(model), need work on console view

PoC/PoC/mainobserver.cpp

 #include <string>
 #include <vector>
+#include <cmath>
+#include <algorithm>
+#include <functional>
+
+#define LIGHTSPEED 10
+
+#define GAMMA(v) (1.0/sqrt(1.0 - (v*v)/(LIGHTSPEED * LIGHTSPEED)))
+
+typedef std::vector<double> Vec;
+typedef std::vector<Vec> Mat;
+
+#define LORENTZ_BOOST(v) (Mat{{GAMMA(v), -GAMMA(v) * (v/LIGHTSPEED)},{-GAMMA(v) * (v/LIGHTSPEED), GAMMA(v)}})
+
+Vec operator*(const Mat &a, const Vec &x) {
+	int i, j;
+	int m = a.size();
+	int n = x.size();
+
+	Vec prod(m);
+
+	for (i = 0; i < m; i++) {
+		prod[i] = 0.;
+		for (j = 0; j < n; j++)
+			prod[i] += a[i][j] * x[j];
+	}
+	return prod;
+}
 
-#define LIGHTSPEED 50
 
 namespace flatland {
 
@@ -14,28 +40,24 @@ namespace flatland {
 	class Flatlandobject
 	{
 
-		Flatlandobject(std::vector<int> theparts, std::tuple<State, double, double, int, int, int> initialstate, Mainworldobserver* thegame)
+		Flatlandobject(/*std::vector<std::tuple<Flatlandobject, double>> theparts,*/ std::tuple<State, double, double, int, double, int> initialstate, Mainworldobserver* thegame)
 		{
-			parts = theparts;
+			//parts = theparts;
 			objecthistory.push_back(initialstate);
 			thegame->objectlist.push_back(std::make_tuple(*this, std::get<3>(initialstate)));
 		}
 
 	public:
-		std::vector<int> parts = {};
-		std::vector<std::tuple<State, double, double, int, int, int>> objecthistory = {}; 
+		bool isPlayer = false;
+		//std::vector<std::tuple<Flatlandobject, double>> parts = {};
+		std::vector<std::tuple<State, double, double, int, double, int>> objecthistory = {}; 
 		// state, time(in main observer clock) at statechange, proper time clock at state change, location(in main observer coordinates) at state change,
 		// velocity(if inertial) relative to mainobserver, proper acceleration(if accelerating) 
 		double propertime;
-		int currentvelocity;
+		double currentvelocity;
 		int currentproperacceleration;
 		
 
-		auto getcenterofmass() -> int
-		{
-			return parts[0];
-		}
-
 		auto changestate(double maintime) -> void
 		{
 			return;
@@ -45,6 +67,58 @@ namespace flatland {
 
 	class Player : public Flatlandobject
 	{
+	public:
+		bool isPlayer = true;
+		//std::vector<std::tuple<Flatlandobject, int>> world = {};
+		char pastlightcone[81] = "--------------------------------------------------------------------------------";
+
+		auto updatepastlightcone(Mainworldobserver* main) -> void
+		{
+			for (auto i = 0; i < 80; ++i)
+			{
+				auto distance = i - 40;
+
+				if (distance == 0) continue;
+				
+				auto point = std::vector<double>{(double)distance, (double)distance};
+
+				point = LORENTZ_BOOST(-this->currentvelocity) * point;
+
+				point = std::vector<double>{point[0] + main->currenttime, point[1] + std::get<1>(main->objectlist[0])};
+				for (auto anobject : main->objectlist)
+				{
+					auto theobject = std::get<0>(anobject);
+					auto findcond = [](auto t, std::tuple<State, double, double, int, double, int> a) { return std::get<1>(a) > t; };
+					auto newfindcond = std::bind(findcond, point[0], std::placeholders::_1);
+					auto it = std::find_if(theobject.objecthistory.begin(), theobject.objecthistory.end(), newfindcond);
+					if (it == theobject.objecthistory.begin())
+					{
+
+					}
+					else 
+					{
+						auto recentstatechange = *std::prev(it);
+						auto mainclocktimeatstatechange = std::get<1>(recentstatechange);
+						auto propertimeclockatstatechange = std::get<2>(recentstatechange);
+						auto maincoordinatelocationatstatechange = std::get<3>(recentstatechange);
+						auto mainrelativevelocity = std::get<4>(recentstatechange);
+						auto properacceleration = std::get<5>(recentstatechange);
+
+						if ((maincoordinatelocationatstatechange < point[1] && mainrelativevelocity < 0.0 && properacceleration < 0.0)
+							|| (maincoordinatelocationatstatechange > point[1] && mainrelativevelocity > 0.0 && properacceleration > 0.0))
+						{
+							continue;
+						}
+						else
+						{
+
+						}
+
+
+					}
+				}
+			}
+		}
 
 	};
 
@@ -52,8 +126,8 @@ namespace flatland {
 	{
 	public:
 
-		std::vector<std::tuple<Flatlandobject, int>> objectlist = {};
-		int playervelocity;
+		std::vector<std::tuple<Flatlandobject, double>> objectlist = {}; // first object is always player
+		//int playervelocity;
 		double currenttime = 0.0;
 
 		auto updatebytick(double tick) -> void;
@@ -64,19 +138,45 @@ namespace flatland {
 	auto Mainworldobserver::updatebytick(double tick) -> void
 	{
 		this->currenttime += tick;
-		for (std::tuple<Flatlandobject, int> a: this->objectlist)
+		for (std::tuple<Flatlandobject, double> a: this->objectlist)
 		{
 			auto theobject = std::get<0>(a);
-			theobject.changestate(this->currenttime);
 			auto objectstate = theobject.objecthistory.back();
+			auto mainclocktimeatstatechange = std::get<1>(objectstate);
+			auto propertimeclockatstatechange = std::get<2>(objectstate);
+			auto maincoordinatelocationatstatechange = std::get<3>(objectstate);
+			auto mainrelativevelocity = std::get<4>(objectstate);
+			auto properacceleration = std::get<5>(objectstate);
+			double newx;
 			if (std::get<0>(objectstate) == INERTIAL)
 			{
-				auto newx = std::get<3>(objectstate) + ;
+				newx = maincoordinatelocationatstatechange + mainrelativevelocity * (this->currenttime - mainclocktimeatstatechange);
+				std::tuple<Flatlandobject, double> newobjectinfo = std::make_tuple(theobject, newx);
+				a.swap(newobjectinfo);
+				free(&newobjectinfo);
+				auto a = std::vector<double>{this->currenttime - mainclocktimeatstatechange, newx- maincoordinatelocationatstatechange};
+				a = LORENTZ_BOOST(theobject.currentvelocity) * a;
+				theobject.propertime = propertimeclockatstatechange + a[0];
+				theobject.currentproperacceleration = 0;
 			}
 			else
 			{
 
 			}
+			/*for (std::tuple<Flatlandobject, double> apart : (theobject.parts))
+			{
+				auto thepart = std::get<0>(apart);
+				auto relativelocationtoCoM = std::get<1>(apart);
+				auto partstate = thepart.objecthistory.back();
+				if (std::get<0>(partstate) == INERTIAL)
+				{
+					auto a = std::vector<double>{ theobject.propertime, (double)relativelocationtoCoM };
+					a = LORENTZ_BOOST(-theobject.currentvelocity) * a;
+					a = std::vector<double>{ a[0] + this->currenttime , a[1] + newx };
+					thepart.currentvelocity = theobject.currentvelocity;
+				}
+			}*/
+			theobject.changestate(this->currenttime);
 		}
 	}