Make a Doom Game with this code

[lucasarts720]

Please. Even if it's a collaborative/community Project. Someone make this dream come true.

[perfectecologietool]

`

<style> body {background-color: #000000; color: #ffffff; } </style> <title>Triangle Test</title> Start End
-----------NECT------

<script> 

var prevision = 22;
var StackTrace = [];
/* Function Template
function nameafunc (args){
var STI = pushStackTrace("nameafunc");
...
popStackTrace(STI);
}
*/

function popStackTrace (ind){
StackTrace.splice(ind,1);
}

function pushStackTrace(nameofun){
let v1 = StackTrace.push(nameofun);
return v1 - 1;
}

function PrintStackTrace(){
let str1 = "+";
for(let i1 = 0; i1 < StackTrace.length; i1++){
str1 += "
+";
for(let i1c = 0; i1c < i1; i1c++){
str1 += "-";
}
str1 += StackTrace[i1];
}
str1 += "
";
return str1;
}

var globalfuname = "black";
function printoutt(xdat, dest = "lbl3"){
let glob = PrintStackTrace();
document.getElementById(dest).innerHTML += "
"+ glob + "-_ _ _ _-
" + xdat;
}
var errcount = 0;
function printoneline(xdat){
errcount++;
document.getElementById("lbl3").innerHTML += ${errcount} + xdat;
}
var dusmds1 = 0;
function debugprinter(strin) {
if(dusmds1 == 200){
document.getElementById("debugger").innerhtml = " ";
dusmds1 = 0;
}else{
dusmds1++;
}
document.getElementById("debugger").innerhtml += <br>${dusmds1} + strin ;
}

function radtodeg(rad){
return (rad * (180/Math.PI));
}

function degtorad(deg){
return (deg * (Math.PI/180));
}

function JSONprintdot(adot){
printoutt(JSON.stringify(adot));
}
function JSONprintLine(aline){
printoutt(JSON.stringify(aline));
}

class DotRegister {
//an array of dots for the application. fetchdot returns a RefDot{}; pushdot envcorporates a RefDot{}; popnum garbages a dot.
constructor () {
// globalfuname = "DotRegister.constructor";
this.first = [];
this.second = [];
}

 pushdot(dot){

let vidid = pushStackTrace("DotRegister.popdot");
//called from only Dot.construct
if(dot instanceof RefDot){
this.second.push(dot);
this.first.push(this.second.length - 1);
popStackTrace(vidid);
return (this.first.length - 1);
}else{alert("not a dot being registered.");}
}

 printdump(ind = 1){
	 //A troubleshooting printdump would be print(index, Stringfy(FIRST) 
	 printoutt(`Dot Register ${this.first.length} first elements, and ${this.second.length} second elements.`);

if(ind >1 ){
printoutt("FIRST
" + JSON.stringify(this.first));
printoutt("SECOND
" + JSON.stringify(this.second));
}
}

 popnum (ind) {

let vidid = pushStackTrace("DotRegister.popnum");
// this.printdump(ind);
if((ind < this.first.length) && (ind > (0 - this.first.length))){// the ind refers to first[]
var FV1 = this.first[ind];
if(FV1 != -1){
this.second.splice((FV1),1);
for(let ite1 = 0; ite1 < this.first.length; ite1++){
if(this.first[ite1] > FV1){this.first[ite1]--;}
}
this.first[ind] = -1;
}
}
popStackTrace(vidid);
}

 fetchdot(ind){

let vidid = pushStackTrace("DotRegister.fetchdot");
if((ind >= 0) && (ind <= this.first.length)){
let rd = this.first[ind];
if(rd != -1){//assume the value is always a cogent index.
var sd = this.second[rd];
popStackTrace(vidid);
return sd;
}
}
//this.printdump();
// printoutt(XXX Out Of Bounds Fetchdot(${ind});
popStackTrace(vidid);
return -1;
}

}

var dotreg = new DotRegister();
var TetDotreg = new DotRegister();

function dr (indexor){

 return dotreg.fetchdot(indexor);;

}
function tr (indexd){
return TetDotreg.fetchdot(indexd);
}

class RefDot{
/*
𐤏ָ𐤐ָ𐤓֙
*/
constructor (p3 = 0 , p4 = 0, p5 = 0 , p0 = 0, no1 = -1) {
let vidid = pushStackTrace("RefDot.constructor");
this.classtype = "RefDot";
// this.points = [this];
this.neighbour;
this.c = 0;
this.setX(p3);
this.setY(p4);
this.setZ(p5);
if(p0 instanceof D1Line){
this.placeInTime(p0);
}else{
this.setTyme(p0);
}
this.colour = "#00FF00";
// this.setParentObject(no1);
this.gcc = 1;//garbage collection count // incase two lines remove the same dot from the register, then
this.atomic = no1;
this.links = [];
this.ID = "";
this.timeaccruer = 0;
this.regind = dotreg.pushdot(this);
popStackTrace(vidid);
}

rubbish(){
	//if(this.timeaccruer == 0){
	if(this.timeaccruer < 0){this.print();}
	if(this.timeaccruer < 1){
		
	dotreg.popnum(this.regind);
	}
}
refresh() {this.integerize();}
pushLink(arefdotref){		
// The Link doesn't need to be a line
// the link can just be a dot
//consider if a dot is MIL and the DIL is wife of Father. Then Father is Son of MIL. 
//Then MIL has husband, MIL has own MIL. and MIL is daughter

if(this.links.length <4){this.links.push(arefdotref);}
//do IDs
// Technically, a Father is a Son, a Mother is a Mother in law and a daughter.
//But one is either male or female.
if(this.ID == "Mother-In-Law"){
}
if(this.ID == "Mother"){
}
if(this.ID == "Father"){
}
if(this.ID == "Son"){
}
if(this.ID == "Daughter"){
}

}	
setEnergy(ejoule = -1){
	let vidid =	 pushStackTrace("Dot.setEnergy");
	var secfla = 0;

if(ejoule < 0){var sec = new Dot(0,0,0,new D1Line(0)); secfla = 1;
ejoule = sec.regind;}

// x.y.z.x.y.z./t.t 
this.energy = dr(ejoule);

if(secfla == 1){dr(ejoule).rubbish();}
popStackTrace(vidid);
}

momentum(ETA = new D1Line(1)){
	let vidid =	 pushStackTrace("momentum");
// x.y.z/t 
// XXX multiply energy CORRECT RATIO according to ETA.duration

// So if Energy is x,y,z t=3
//then forevery t=3, the dot moves xyz
//but if ETA = 2, then TimeFlow has moved t=2,
//thus energy applied is 2/3 * xyz
// ie: ETA/Energy.t
//eg: ETA.t/Energy.t * Energy.xyz = World.xyz
// XXX HOW TO DO THIS WITHOUT DIVISION?
// 1) have a local counter that accrues until natural factor of energy.t
let heretimeratio = 0;
if(ETA.duration < this.energy.t.duration){
this.timeaccruer += ETA.duration;
//i.e: timeaccruer = 2,4,6
if(0 == (this.timeaccruer % this.energy.t.duration)){
heretimeratio = this.timeaccruer / this.energy.t.duration;
this.setX(this.x + (this.energy.x * heretimeratio));
this.setY(this.y + (this.energy.y * heretimeratio));
this.setZ(this.z + (this.energy.z * heretimeratio));
this.timeaccruer = 0;
}
}
if(ETA.duration > this.energy.t.duration){
//eta =3 energy.t =2
this.timeaccruer += ETA.duration;
//timeaccruer = 3,6
if(0 == (this.timeaccruer % this.energy.t.duration)){
heretimeratio = this.timeaccruer / this.energy.t.duration;
this.setX(this.x + (this.energy.x * heretimeratio));
this.setY(this.y + (this.energy.y * heretimeratio));
this.setZ(this.z + (this.energy.z * heretimeratio));
this.timeaccruer = 0;
}
}
popStackTrace(vidid);
}

checkarg(x1){
//private function.
if(x1 instanceof RefDot){return x1.regind;}else{
//should check if x1 < first.length
if(x1 < dotreg.first.length){
return x1;}else{
//FIX HERE OPTION
return x1;
}
}
}

setConstant (newx){
    this.c = Number(newx);
}
setX (newx){
    this.x = Number(newx);
}
setY (newy){
    this.y = Number(newy);
}
setZ (newz){
    this.z = Number(newz);
}
setTyme(newt){

let vidid = pushStackTrace("setTyme");
if(newt instanceof D1Line) {
this.t = newt;
}else{
this.t = new D1Line(Number(newt));}
popStackTrace(vidid);
}
setT(variabl){this.setTyme(variabl);}
placeInTime (aD4Line){
let vidid = pushStackTrace("RefDot.placeInTime");;
if(aD4Line instanceof D1Line){
this.t = aD4Line;
}else{
printoutt("XXX D1line.placeInTime XXX");
}
popStackTrace(vidid);
}

setAtom(AMU = 3){
	this.atomic = AMU; 
}

resetxyzt(newdot){
	newdot = checkdotarg(newdot);
	this.setX(dr(newdot).x);
	this.setY(dr(newdot).y);
	this.setZ(dr(newdot).z);
	this.setTyme(dr(newdot).t);
	
	
}

setFrameOrigin(Ori) {

let vidid = pushStackTrace("RefDot.setFrameOrigin");
/frame origin as a set of coords sits inside the "universal" coord system. as does this.x this.y, is within universal coordsystem
//but when framedot gets set within setX, then framedot is relative to FrameOrigin (so this.x = 4 and this.shadowx = 2, then frameorigin.x = 2)
//seems like if i use a secondary dot, then the class Dot while be relativitically inclined, also becomes a 1D line masquerading as a 0D dot...but then all numbers are 1D... so the value itself is relative to assumed origin(0,0,0) with frameorigin t he origin is explicit not assumed./
if(Ori instanceof RefDot){this.FrameOrigin = Ori;}
popStackTrace(vidid);
}
setParentObject (obj) {//for if instanceof actions
this.parentObject = obj;
}

shiftplace(q1 = 0,q2 = 0,q3 = 0,q4 = 0) {
//adds these coordinates to this Dot`
this.setX(this.x + q1);
this.setY(this.y + q2);
this.setZ(this.z + q3);
if(0 == this.t.whetherpointintersects(q4)){
this.t.shiftanyendpoint(q4);}
}

copyOfDot () {
let vidid = pushStackTrace("RefDot.copyOfDot");
let t1 = new RefDot(this.x, this.y, this.z, 1, this.atomic);
t1.placeInTime(this.t);
t1.colour = this.colour;
popStackTrace(vidid);
return t1.regind;
}

addDot (addenddot) {
addenddot = this.checkarg(addenddot);
let vidid = pushStackTrace("RefDot.addDot");
if(dr(addenddot) instanceof RefDot){
this.setX(this.x + dr(addenddot).x);
this.setY(this.y + dr(addenddot).y);
this.setZ(this.z + dr(addenddot).z);
//this.C += addeddot.c
this.t.addD1Line(dr(addenddot).t);
}
popStackTrace(vidid);
}

subtractDot (addenddot){

addenddot = this.checkarg(addenddot);

let vidid = pushStackTrace("RefDot.subtractdot");
if(dr(addenddot) instanceof RefDot){
this.setX(this.x - dr(addenddot).x);
this.setY(this.y - dr(addenddot).y);
this.setZ(this.z - dr(addenddot).z);
this.t.minusD1Line(dr(addenddot).t);
}
popStackTrace(vidid);
}

singlefactormultiply (factor){

let vidid = pushStackTrace("RefDot.singlefactormultiply");
//printoutt(${this.x} and ${factor} + JSON.stringify(factor));
this.setX(this.x * factor);
this.setY(this.y * factor);
//printoutt(${this.y} and ${factor});
this.setZ(this.z * factor);
// printoutt(${this.z} and ${factor});
popStackTrace(vidid);
}

matrixmultiply (facdot){	
facdot = this.checkarg(facdot);

let vidid = pushStackTrace("RefDot.matrixmultiply");
this.setX(this.x * dr(facdot).x);
this.setY(this.y * dr(facdot).y);
this.setZ(this.z * dr(facdot).z);
popStackTrace(vidid);
}

dotproduct (facdot){
	facdot = this.checkarg(facdot);

let vidid = pushStackTrace("RefDot.dotproduct");
popStackTrace(vidid);
return ((this.x * dr(facdot).x)+(this.y * dr(facdot).y)+(this.z * dr(facdot).z));
}

returndelta (compdot){
	compdot = this.checkarg(compdot);

let vidid = pushStackTrace("RefDot.returndelta");
if(dr(compdot) instanceof RefDot){
var tre = this.copyOfDot();
dr(tre).subtractDot(compdot);
popStackTrace(vidid);
return tre;
}
popStackTrace(vidid);
}

//foresight
changeplace (p1,p2,p3){
	this.setX(p1); this.setY(p2);this.setZ(p3);
}

changetime (t1) {

	if(t1 instanceof D1Line) {
			this.t = t1;
	}else{	this.t.extendbysignedEW(t1);} 

}

isSpatiallyEquivalent(secdot = -1, gran = 3){
let vidid = pushStackTrace("RefDot.isSpatiallyEquivalent");
if(secdot == -1){return 0;}
secdot = this.checkarg(secdot);
let tx, sx, ty, sy, tz, sz;
tx = Number.parseFloat(this.x).toFixed(gran);
ty = Number.parseFloat(this.y).toFixed(gran);
tz = Number.parseFloat(this.z).toFixed(gran);
sx = Number.parseFloat(dr(secdot).x).toFixed(gran);
sy = Number.parseFloat(dr(secdot).y).toFixed(gran);
sz = Number.parseFloat(dr(secdot).z).toFixed(gran);
if(tx != sx){return 0;
}else if(ty != sy){return 0;
}else if(tz != sz){return 0;
}else{return 1;}

popStackTrace(vidid);
}

 wasequivalent (secdot = -1, xf = 1, yf = 1, zf = 1, tf = 1) {

let vidid = pushStackTrace("RefDot.wasequivalent");
var secfla = 0;
if(secdot == -1){var sec = new Dot(0,0,0,new D1Line(0)); secfla = 1;
secdot = sec.regind;}
secdot = this.checkarg(secdot);
/* Secdot is secondary dot to compare this dot to.
xf is this x flag about if checking this axis should occur
yf is this y flag about if checking y axis should occur zf is this z flag about if checking z axis should occur
*/
var retval = -1;
if((xf == 1)&& (dr(secdot).x != this.x)){ retval = 0;
} else if((yf == 1)&&(dr(secdot).y != this.y)){ retval = 0;
}else if((zf == 1)&&(dr(secdot).z != this.z)){ retval = 0;
} else if((tf == 1)&&(0 == this.t.whetherD1Lineequiv(dr(secdot).t))){
retval = 0;
}else{
retval = 1;}

if(secfla == 1){dr(secdot).rubbish();}
popStackTrace(vidid);
return retval;
}

describedot () {
    return `dot ${this.regind} is ( ${this.x} , ${this.y} , ${this.z} , t = ${this.t.start} to ${this.t.end} ; constant = ${this.c} with colour ${this.colour} and atomic size ${this.atomic}`; 
}

print(){
let x3s = JSON.stringify(this);
// let x3s = this.describedot();
printoutt(x3s);
}

integerize () {
	this.x -= this.x%1;
	this.y -= this.y%1;
	this.z -= this.z%1;
	{//XXX D1Line should have a "change duration" so that the functionality of the start and end isn't lost (i.e: start = commencement  end=demise
	let tt = this.t.duration;
	tt -= tt % 1;
	this.t = new D1Line(tt);
	}
}

rotateAroundTheXAxis (ang){
/* The axes are relative to the coordinates.

*/
let ny, nz;
ny = (this.y * Math.cos(ang)) - (this.z * Math.sin(ang));
nz = (this.y * Math.sin(ang)) + (this.z * Math.cos(ang));
this.setY(ny);
this.setZ(nz);
}

rotateAroundTheYAxis (ang) {
let nz, nx;
nz = ( this.z * Math.cos(ang)) - (this.x * Math.sin(ang));
nx = ( this.z * Math.sin(ang) ) + (this.x * Math.cos(ang));
this.setZ(nz);
this.setX(nx);
}

rotateAroundTheZAxis (ang){
let nx, ny;
nx = (this.x * Math.cos(ang)) - (this.y * Math.sin(ang));
ny = (this.x * Math.sin(ang)) + (this.y * Math.cos(ang));
this.setX(nx);
this.setY(ny)

}

Rotate(xa=0,ya=0,za=0){
this.rotateAroundTheXAxis(xa);
this.rotateAroundTheYAxis(ya);
this.rotateAroundTheZAxis(za);
}

isPointOnPlane (poin){
//assumes this c is set, that this a cartesian plane.
// Normal . (x,y,z) = Normal . (point) = constant
//normal . point = constant
poin = this.checkarg(poin);
let ans1 = this.dotproduct(poin);
let ans2 = Number.parseFloat(ans1).toFixed(6);
let ans3 = Number.parseFloat(this.c).toFixed(6);
if(ans2 == ans3){ return 1;}
return 0;
}

}

class D1Line {
constructor (leng = 0){
//these lines exist independently of an axial world. thus minimum of start is 0...
this.start = 0;
if(leng < 0){leng *= -1;}
this.center = this.start + (leng/2);
this.end = this.start + leng;

this.distance = leng;
this.duration = this.distance;
}

findUnion (arg1){
//@purpose@ returns a Dline that sits where (D1Line)this and (D1Line)arg1 intersect.  

if(arg1 instanceof D1Line){
let unionstart =-1; let unionend =-1;//init

if( (this.start <= arg1.start) && (this.end >= arg1.start)){
if(arg1.end > this.end){unionstart = arg1.start;unionend = this.end;
}else{unionstart = arg1.start;unionend = arg1.end;}
}
if( (arg1.start <= this.start) && (arg1.end >= this.start)){
if(this.end > arg1.end){ unionstart = this.start; unionend = arg1.end;
}else{ unionstart = this.start;unionend = this.end;}
}

if((unionstart == -1) || (unionend == -1)){printoutt("-------------EROR in D1LINE===========");}
var retT = new D1Line(unionend-unionstart);
retT.shiftstartpoint(unionstart);
return retT;
}else{Alert("not D1Line in findunion()");}

}

resolveComponents (){
 // Any line exists, where 2->3 + 3->4 = 2->4 but negative numbers require axis.

if(this.start < 0) {
let x1 = this.start;
this.start -= x1;
this.end -= x1;
}
if(this.start > this.end){
let x1 = this.end;
this.end = this.start; this.start = x1;
}
if( (this.end - this.duration) != this.start){
this.distance = this.end - this.start;
}
this.duration = this.distance;

}

whetherpointintersects (pnt){
if((this.start <= pnt) && (pnt <= this.end)){return 1;}else{return 0;}
}

whetherD1Lineequiv (D1here){
if ((D1here.distance == this.distance)&&(D1here.start == this.start)&&(D1here.end == this.end)){return 1;}else{return 0;
}
}

shiftstartpoint (sp){
this.start = sp;
this.resolveComponents();
}

shiftendpoint (ep){
this.end = ep;
this.resolveComponents();
}

shiftanyendpoint (st){
if(this.whetherpointintersects(st)){
let sd = st - this.start;
let ed = this.end - st;
if(sd > ed){this.shiftendpoint(st);}else{this.shiftstartpoint(st);}
}else{
if(st < this.start){this.start = st;}
if(st > this.end){this.end = st;}
}
this.resolveComponents();
}

resizeeastfromstart (newlen){
this.end = this.start + newlen;
this.resolveComponents();
}

//add -
resizewestfromstart (addle){
this.start = this.start - addle;
this.resolveComponents();
}
//minus +
resizewestfromend (newlen){
this.start = this.end - newlen;
this.resolveComponents();
}

//minus -
resizeeastfromend (addle){
this.end = this.end + addle;
this.resolveComponents();
}

singlefactormultiply (mfact){
let nd = this.distance * mfact;
if(mfact > 0){
this.resizeeastfromstart(nd);
}else{
this.resizewestfromend(nd);
}
}

extendbysignedEW = function (signewlen){
if(signewlen < 0){
this.start += signewlen;
}else{
this.end += signewlen;
}
this.resolveComponents();
}

addD1Line (ODL){
if(ODL instanceof D1Line){
ODL.resolveComponents(); //scrub
this.resolveComponents();//scrub
this.shiftendpoint(this.end + ODL.distance);//add
}
}

minusD1Line (ODL){
if(ODL instanceof D1Line){
ODL.resolveComponents();
this.resolveComponents();
this.shiftendpoint(this.end - ODL.distance);
}
}

copyD1Line (){
var r1 = new D1Line(this.distance);
r1.start = this.start; r1.end = this.end;
return r1;
}
}

function checkdotarg (x1) {
//private function.
if(x1 instanceof RefDot){return x1.regind;}else{
//should check if x1 < first.length
if(x1 < dotreg.first.length){
return x1;}else{
//FIX HERE OPTION
return x1;
}
}
}

var globalflag91 = 0;

class LineRegister {

constructor (){
this.first = [];
this.second = [];
}

printdump(ind = 0){
//A troubleshooting printdump would be print(index, Stringfy(FIRST)
printoutt(in LINE register There are ${this.first.length} first elements, and ${this.second.length} second elements.);
if(ind > 0){
printoutt("FIRST
" + JSON.stringify(this.first));
printoutt("SECOND
" + JSON.stringify(this.second));
}
}

matchline(artic){
//finds lines which are purposely created using the same dots.
if(artic instanceof RefLine){
// if(artic.AllowDuplication == 1){return -1;}
for(let it1 = 0; it1 < this.first.length; it1++){
let va1 = this.first[it1];
if(va1 != -1){
if(((this.second[va1].start == artic.start)&&(this.second[va1].end == artic.end))){
//||((this.second[va1].end == artic.start)&&(this.second[va1].start == artic.end))){//match found;
// this.printdump();
this.second[va1].timeaccruer++;
return it1;
}
}
}
}
return -1;
}

pushline(onru){
let vidid = pushStackTrace("LineRegister.pushline");
if(onru instanceof RefLine){
//this.printdump();
let va2 = this.matchline(onru);
if(va2 == -1){
this.second.push(onru);
this.first.push( (this.second.length - 1) );
onru.regind = this.first.length - 1;
popStackTrace(vidid);
return (onru.regind);
}else{

popStackTrace(vidid);
onru.regind = va2;
return (onru.regind); 

}
}

}

popline(ind){
let vidid = pushStackTrace("LineRegister.popnum");
//this.printdump(ind);
if((ind < this.first.length) && (ind > (0 - this.first.length))){
var memx1 = this.first[ind];
if(memx1 != -1){
this.second.splice((memx1),1);
for(let ite1 = 0; ite1 < this.first.length; ite1++){
if(this.first[ite1] > memx1){
this.first[ite1]--;
}
}
this.first[ind] = -1;
}
}
popStackTrace(vidid);
}

fetchline(ind){
let vidid = pushStackTrace("LineRegister.fetchline");
if((ind >= 0) && (ind <= this.first.length)){
let rd = this.first[ind];
if(rd != -1){//assume the value is always a cogent index.
var sd = this.second[rd];
popStackTrace(vidid);
return sd;
}
}
// printoutt(XXX Out Of Bounds Fetchline(${ind});
popStackTrace(vidid);
return -1;

}

}

var linreg = new LineRegister();
function lr (indx){
return linreg.fetchline(indx);
}

class RefLine {
//𐤀֑𐤅ֹ𐤓

/* Cartesian Form: 
this.xcomp/this.xDA = this.ycomp/this.yDA = this.zcomp/this/zDA 
*/
    constructor (dot1, dot2){

let vidid = pushStackTrace("RefLine.constructor");
//Takes to integers as arguments,
// which are the DotRegister indexes for the two dots.
this.classtype = "RefLine";
this.finiteinfinity = 100000;
//XXX The One and Only check for instanceof RefDot
if(dot1 instanceof RefDot){
this.start = dot1.regind;
} else { this.start = dot1; }
if(dot2 instanceof RefDot){
this.end = dot2.regind;
} else { this.end = dot2;
}

dr(this.start).timeaccruer++;
dr(this.end).timeaccruer++;
this.timeaccruer = 0;
this.p = [];
this.p[0] = this.start;

this.points = [this.start, this.end];
// this.lines = [this];
this.colour = "black";
this.siz = "3";
this.refresh();
this.regind = linreg.pushline(this);
popStackTrace(vidid);
}

checkarg(argx){
if(argx instanceof RefLine){
return argx.regind;
}else{
if(argx < linreg.first.length){ return argx;}else{return argx;}
}
}
print(ver = 1){
printoutt(${this.start} and ${this.end} , for ${this.distance} where center is ${this.center});
if(ver > 1){
printoneline("start: " + JSON.stringify(dr(this.start)) + "
end: " + JSON.stringify(dr(this.end)) + "
delta: " + JSON.stringify(dr(this.delta)) + "
and center: " + JSON.stringify(dr(this.center)) + "
");
this.printouttheparametricformat();
}
}
doDelta(){
let vidid = pushStackTrace("RefLine.doDelta");
if(dr(this.delta) instanceof RefDot){
dr(this.delta).timeaccruer--;
dr(this.delta).rubbish();
this.p.splice(1,1);
}

// printoutt(JSON.stringify(this));

let dx = dr(this.end).x - dr(this.start).x;
let dy = dr(this.end).y - dr(this.start).y;
let dz = dr(this.end).z - dr(this.start).z;
let dt = dr(this.end).t.copyD1Line();
dt.minusD1Line(dr(this.start).t);
if(isNaN(dz)){
//this.print();
printoutt(NaN IN DELTA<br>);
//dr(this.end).print();
//dr(this.start).print();
}

let m1 = new RefDot(dx,dy,dz,dt);
m1.timeaccruer++;
this.delta = m1.regind;
this.p[1] = this.delta;

 popStackTrace(vidid);

}
doCenter(){
if(dr(this.center) instanceof RefDot){
dr(this.center).timeaccruer--;
dr(this.center).rubbish();
}
this.center = dr(this.delta).copyOfDot();
dr(this.center).timeaccruer++;
dr(this.center).singlefactormultiply(0.5);
dr(this.center).addDot(this.start);

}
doDistance(){
let vidid = pushStackTrace("RefLine.doDistance");
let Hx = dr(this.delta).x * dr(this.delta).x;
let Hy = dr(this.delta).y * dr(this.delta).y;
let Hz = dr(this.delta).z * dr(this.delta).z;
this.distance = Math.sqrt(Hx + Hy + Hz);
popStackTrace(vidid);
}
rubbish(deg = 1){
//deg = 0 remove self (delta + center)
//deg = 1 remove self and 2 vertices
if(deg == 1){
dr(this.start).timeaccruer--;
dr(this.end).timeaccruer--;
dr(this.start).rubbish();
dr(this.end).rubbish();
}
dr(this.center).timeaccruer--;
dr(this.center).rubbish();
dr(this.delta).timeaccruer--;
dr(this.delta).rubbish();
this.timeaccruer--;
if(this.timeaccruer < 1){
linreg.popline(this.regind);}
}
refresh(){
this.doDelta();
this.doCenter();
this.doDistance();
}

isXInLineRange(ecs){

if(dr(this.delta).x >= 0){

    if(( ecs >= dr(this.start).x)&&(ecs <= dr(this.end).x)){
    return true;
    }else{return false;}
} else {

    if( (ecs <= dr(this.start).x)&&(ecs >= dr(this.end).x)){

        return true;}else{
			;return false;}
}

}
isYInLineRange(ecs){
if(dr(this.delta).y >= 0){
if(( ecs >= dr(this.start).y)&&(ecs <= dr(this.end).y)){
return 1;
}else{return 0;}
}else{
if( (ecs <= dr(this.start).y)&&(ecs >= dr(this.end).y)){
return 1;}else{return 0;}
}
}
isZInLineRange(ecs){
if(dr(this.delta).z >= 0){
if(( ecs >= dr(this.start).z)&&(ecs <= dr(this.end).z)){
return 1;
}else{return 0;}
}else{
if( (ecs <= dr(this.start).z)&&(ecs >= dr(this.end).z)){
return 1;}else{return 0;}
}
}

isDotOnLine(QDot){
//Checks if this QDot is on the line segment.
QDot = checkdotarg(QDot);
if(QDot == -1){return 0;}
if(this.isXInLineRange(dr(QDot).x) == 0){return 0;}
// x = p0 + tp1 ; x - p0) / p1 = t
var para = ( dr(QDot).x - dr(this.p[0]).x ) / dr(this.p[1]).x;

var an1 = this.Euclid2ndPostulateByParameter(para);
printoutt(JSON.stringify(dr(an1)));
return dr(QDot).isSpatiallyEquivalent(an1,1,1,1);

}

translateByAddition(addenddot){
// addenddot = dr(this.start).checkarg(addenddot);
dr(this.start).addDot(addenddot);
dr(this.end).addDot(addenddot);
this.refresh();
}
translateBySubtraction(addenddot){
dr(this.start).subtractDot(addenddot);
dr(this.end).subtractDot(addenddot);
this.refresh();
}

rotateAroundAxes(xa = 0, ya=0, za=0){
if(xa != 0){
dr(this.start).rotateAroundTheXAxis(xa);
dr(this.end).rotateAroundTheXAxis(xa);
}
if(ya != 0){
dr(this.start).rotateAroundTheYAxis(ya);
dr(this.end).rotateAroundTheYAxis(ya);
}
if(za != 0){
dr(this.start).rotateAroundTheZAxis(za);
dr(this.end).rotateAroundTheZAxis(za);
}

}
rotateAroundStart(xa = 0, ya=0, za=0){
let XD = dr(this.start).copyOfDot();
this.translateBySubtraction(XD);
this.rotateAroundAxes(xa,ya,za);
this.translateByAddition(XD);
}
rotateAroundEnd(xa = 0, ya=0, za=0){
let XD = dr(this.end).copyOfDot();
this.translateBySubtraction(XD);
this.rotateAroundAxes(xa,ya,za);
this.translateByAddition(XD);

}
rotateAroundPivot(xa = 0, ya=0, za=0, piv = 0){
let XD = dr(piv).copyOfDot();
this.translateBySubtraction(XD);
this.rotateAroundAxes(xa,ya,za);
this.translateByAddition(XD);

}

setEnd(newend){
let vidid = pushStackTrace("RefLine.setEnd");

if(newend instanceof RefDot){
 	dr(this.end).timeaccruer--;
	dr(this.end).rubbish();
	this.end = newend.regind;
	newend.timeaccruer++;
}else{
	if(dr(newend) instanceof RefDot){
	 	dr(this.end).timeaccruer--;
		dr(this.end).rubbish();
		this.end = dr(newend).regind;
		dr(newend).timeaccruer++;
	}
}
this.refresh();
popStackTrace(vidid);

}
setStart(newend){
let vidid = pushStackTrace("RefLine.setStart");
if(newend instanceof RefDot){
dr(this.start).timeaccruer--;
dr(this.start).rubbish();
this.start = newend.regind;
newend.timeaccruer++;
}else{
if(dr(newend) instanceof RefDot){
dr(this.start).timeaccruer--;
dr(this.start).rubbish();
this.start = dr(newend).regind;
dr(newend).timeaccruer++;
}
}
this.refresh();
popStackTrace(vidid);
}

crawlDistanceFromStart(newdist){
let vidid = pushStackTrace("RefLine.changeDistanceChangeEnd");
let rat = newdist/this.distance;
let nede = dr(this.delta).copyOfDot();
dr(nede).singlefactormultiply(rat);
var neen = dr(this.start).copyOfDot(); dr(neen).addDot(nede);
dr(nede).rubbish();
popStackTrace(vidid);
return neen;
}

changeDistanceChangeEnd(newdist){
let vidid = pushStackTrace("RefLine.changeDistanceChangeEnd");
//ifnewdist >0 from start if newdist <0 from end.
//or ifnewdist >0 then above start else if newdist <0 then below start.
let rat = newdist/this.distance;
let nede = dr(this.delta).copyOfDot();
dr(nede).singlefactormultiply(rat);
var neen = dr(this.start).copyOfDot();
dr(neen).addDot(nede);
this.setEnd(neen);
popStackTrace(vidid);
}
changeDistanceChangeStart(newdist){
let vidid = pushStackTrace("RefLine.changeDistanceChangeStart");
let rat = newdist/this.distance;
let nede = dr(this.delta).copyOfDot();
dr(nede).singlefactormultiply(rat);
let neen = dr(this.end).copyOfDot();
dr(neen).subtractDot(nede);
this.setStart(neen);
popStackTrace(vidid);
}
changeDistance(dis){
this.changeDistanceChangeEnd(dis);
}

copyOfLine_MemorySensitive(){
//This function allows LineRegister to match lines which share both dots in either order. Therefore producing clones of lines, which seperates the application from the mechination
var x1 = new RefLine(this.start, this.end);
x1.colour = this.colour;
x1.siz = this.siz;
return x1.regind;
}
copyOfLine_MemoryInsensitive(){
var d2 = dr(this.start).copyOfDot();
var d3 = dr(this.end).copyOfDot();
var x1 = new RefLine(d2,d3);
x1.colour = this.colour;
x1.siz = this.siz;
return x1.regind;
}
copyOfLine(){
return this.copyOfLine_MemoryInsensitive();
}

Euclid2ndPostulateByY(wai){
var v1;
// x = p[0].x + t*p[1].x
var parameterT;
// if an yx line at z=3
if(dr(this.p[1]).y == 0){
if(wai == dr(this.p[0]).y){return this.p[0];}else{return -1;}
} else {
parameterT = wai - dr(this.p[0]).y;
parameterT /= dr(this.p[1]).y;}
//if(dr(this.p[1]).z != 0){v1 = zee/dr(this.p[1]).z;}else{v1 = 0;}
let retv = dr(this.p[1]).copyOfDot();

dr(retv).singlefactormultiply(parameterT);

dr(retv).addDot(this.p[0]);
return retv;
}
Euclid2ndPostulateByX(ex){
var v1;
// x = p[0].x + tp[1].x
var parameterT;
// if an yx line at z=3
if(dr(this.p[1]).x == 0){
if(ex == dr(this.p[0]).x){return this.p[0];}else{return -1;}
} else {
parameterT = ex - dr(this.p[0]).x;
parameterT /= dr(this.p[1]).x;}
//if(dr(this.p[1]).z != 0){v1 = zee/dr(this.p[1]).z;}else{v1 = 0;}
let retv = dr(this.p[1]).copyOfDot();
//printoutt(${parameterT});``
dr(retv).singlefactormultiply(parameterT);
dr(retv).addDot(this.p[0]);
return retv;
}
Euclid2ndPostulateByZ(zee){
var v1;
// x = p[0].x + tp[1].x
var parameterT;
// if an yx line at z=3
if(dr(this.p[1]).z == 0){
if(zee == dr(this.p[0]).z){return this.p[0];}else{return -1;}
} else {
parameterT = zee - dr(this.p[0]).z;
parameterT /= dr(this.p[1]).z;}
//if(dr(this.p[1]).z != 0){v1 = zee/dr(this.p[1]).z;}else{v1 = 0;}
let retv = dr(this.p[1]).copyOfDot();
dr(retv).singlefactormultiply(parameterT);
dr(retv).addDot(this.p[0]);
return retv;
}
Euclid2ndPostulateByParameter(param){
let retv = dr(this.p[1]).copyOfDot();
dr(retv).singlefactormultiply(param);
dr(retv).addDot(this.p[0]);
return retv;
}

InfInt3(lin){
lin = checklinearg(lin);
var A = this;
var B = lr(lin);
//printoutt("A.p1 is " + JSON.stringify(dr(A.p[1])));
//printoutt("B.p1 is " + JSON.stringify(dr(B.p[1])));

//var Pay0,Pax0, Pay1, Pax1, Pby0, Pbx0, Pby1, Pbx1;
if((dr(A.p[1]).x != 0)&&(dr(A.p[1]).y != 0)){
var Pay0 = dr(A.p[0]).y;
var Pax0 = dr(A.p[0]).x;
var Pay1 = dr(A.p[1]).y;
var Pax1 = dr(A.p[1]).x;

var Pby0 = dr(B.p[0]).y;
var Pbx0 = dr(B.p[0]).x;
var Pby1 = dr(B.p[1]).y;
var Pbx1 = dr(B.p[1]).x;
}else if((dr(B.p[1]).x != 0)&&(dr(B.p[1]).y != 0)){
var Pby0 = dr(A.p[0]).y;
var Pbx0 = dr(A.p[0]).x;
var Pby1 = dr(A.p[1]).y;
var Pbx1 = dr(A.p[1]).x;

var Pay0 = dr(B.p[0]).y;
var Pax0 = dr(B.p[0]).x;
var Pay1 = dr(B.p[1]).y;
var Pax1 = dr(B.p[1]).x;
}else if((dr(A.p[1]).x != 0)&&(dr(A.p[1]).z != 0)){
var Pay0 = dr(A.p[0]).z;
var Pax0 = dr(A.p[0]).x;
var Pay1 = dr(A.p[1]).z;
var Pax1 = dr(A.p[1]).x;

var Pby0 = dr(B.p[0]).z;
var Pbx0 = dr(B.p[0]).x;
var Pby1 = dr(B.p[1]).z;
var Pbx1 = dr(B.p[1]).x;
}else if((dr(B.p[1]).x != 0)&&(dr(B.p[1]).z != 0)){
var Pby0 = dr(A.p[0]).z;
var Pbx0 = dr(A.p[0]).x;
var Pby1 = dr(A.p[1]).z;
var Pbx1 = dr(A.p[1]).x;

var Pay0 = dr(B.p[0]).z;
var Pax0 = dr(B.p[0]).x;
var Pay1 = dr(B.p[1]).z;
var Pax1 = dr(B.p[1]).x;
}else if((dr(A.p[1]).y != 0)&&(dr(A.p[1]).z != 0)){
var Pay0 = dr(A.p[0]).z;
var Pax0 = dr(A.p[0]).y;
var Pay1 = dr(A.p[1]).z;
var Pax1 = dr(A.p[1]).y;

var Pby0 = dr(B.p[0]).z;
var Pbx0 = dr(B.p[0]).y;
var Pby1 = dr(B.p[1]).z;
var Pbx1 = dr(B.p[1]).y;
}else if((dr(B.p[1]).y != 0)&&(dr(B.p[1]).z != 0)){
var Pby0 = dr(A.p[0]).z;
var Pbx0 = dr(A.p[0]).y;
var Pby1 = dr(A.p[1]).z;
var Pbx1 = dr(A.p[1]).y;

var Pay0 = dr(B.p[0]).z;
var Pax0 = dr(B.p[0]).y;
var Pay1 = dr(B.p[1]).z;
var Pax1 = dr(B.p[1]).y;

}else {
/*
// This switch means the function works atleast one of the two lines are axial lines. If both lines are axial lines, then
printoutt("Delta of A is " + JSON.stringify(dr(A.p[1])));
printoutt("Delta of B is " + JSON.stringify(dr(B.p[1])));

//By My erroneousReasoning, At this level of comparison , adding the A.start to B.start should yeild the intersection, and if the intersection lies within the segment bounds...
var idid = dr(A.start).copyOfDot();
dr(idid).addDot(B.start);
var RA1 = A.isDotOnLine(idid);
printoneline("
A start is
"+JSON.stringify(dr(A.start)));
*/
// if for A's nonzero delta dim, B's dim falls within A's range, then B's dim is that dim of the answer vector.
var x3 = 1;
var y3 = 2;
var z3 = 3;
if((dr(A.delta).x != 0)&&(dr(B.delta).x == 0)&&(A.isXInLineRange(dr(B.start).x))){
x3 = dr(B.start).x;
}else if((dr(B.delta).x != 0)&&(dr(A.delta).x == 0)&&(B.isXInLineRange(dr(A.start).x))){
x3 = dr(A.start).x;
}else if((dr(B.delta).x == 0)&&(dr(A.delta).x == 0)&&(dr(B.start).x == dr(A.start).x)){
x3 = dr(A.start).x;
}

if((dr(A.delta).y != 0)&&(dr(B.delta).y == 0)&&(A.isYInLineRange(dr(B.start).y))){
	y3  = dr(B.start).y;
}else if((dr(B.delta).y != 0)&&(dr(A.delta).y == 0)&&(B.isYInLineRange(dr(A.start).y))){
	y3  = dr(A.start).y;
}else if((dr(B.delta).y == 0)&&(dr(A.delta).y == 0)&&(dr(B.start).y == dr(A.start).y)){
	y3  = dr(A.start).y;
}


if((dr(A.delta).z != 0)&&(dr(B.delta).z == 0)&&(A.isZInLineRange(dr(B.start).z))){
	z3  = dr(B.start).z;
}else if((dr(B.delta).z != 0)&&(dr(A.delta).z == 0)&&(B.isZInLineRange(dr(A.start).z))){
	z3  = dr(A.start).z;
}else if((dr(B.delta).z  == 0)&&(dr(A.delta).z == 0)&&(dr(B.start).z == dr(A.start).z)){
	z3  = dr(A.start).z;
}

var idid = new RefDot(x3,y3,z3);

//printoneline("<br><br><br>B start is<BR>"+JSON.stringify(dr(B.start))+"<BR>");
//printoutt(`Intersection inside ${x3} and ${y3} and ${z3} and  linefunction says ` + JSON.stringify(idid));
return idid.regind;
}    

let Numc = Pay0 - Pby0 ;
Numc /= (0 - Pay1 );
let Numd = dr(A.p[0]).x - Pbx0;
Numd /= (0 - Pax1 );
//printoneline(<br>Numc is ${Numc} and numd = ${Numd}<br>);
let Num1 = Numc - Numd;
Num1 *= Pax1 * Pay1;
let Den = ( Pay1 * Pbx1 ) - (Pax1 * Pby1);
//printoneline(<br>num1 is ${Num1} and deno = ${Den} <br>);
var Esans;
if(Den != 0){Esans = Num1 / Den;}else{return -3;}
var AN = this.Euclid2ndPostulateByParameter(Esans);
let Xans = Pax0 + (Pax1 * Esans);
let Ans = A.Euclid2ndPostulateByX(Xans);
//printoutt("INF INT THREE BY X " + JSON.stringify(dr(Ans)));
//printoutt("INF INT BY PARAMETER" + JSON.stringify(dr(AN)));
return Ans;

}

dydxM(){
if(dr(this.delta).x != 0){
return ( dr(this.delta).y / dr(this.delta).x );
}else{return 0;}
}
dydxC(){ //y = mx + c //c = y - mx
return ( dr(this.start).y - (this.dydxM() * dr(this.start).x) );
}
dydzM() {
if( dr(this.delta).z != 0){
return ( dr(this.delta).y / dr(this.delta).z );
}else{ return 0;}
}
dydzC(){ //y = mx + c //c = y - mx
return ( dr(this.start).y - (this.dydzM() * dr(this.start).z) );
}
dzdxM(){
if( dr(this.delta).x != 0){
return ( dr(this.delta).z / dr(this.delta).x );
}else{return 0;}
}
dzdxC(){ //y = mx + c //c = y - mx
return ( dr(this.start).z - (this.dzdxM() * dr(this.start).x) );
}
dzdyM(){
if( dr(this.delta).y != 0){
return ( dr(this.delta).z / dr(this.delta).y );
}else{return 0;}
}
dzdyC(){ //y = mx + c //c = y - mx
return ( dr(this.start).z - (this.dzdyM() * dr(this.start).y) );
}
dxdyM(){
if( dr(this.delta).y != 0){
return ( dr(this.delta).x / dr(this.delta).y );
}else{return 0;}
}
dxdyC(){ //y = mx + c //c = y - mx
return ( dr(this.start).x - (this.dxdyM() * dr(this.start).y) );
}
dxdzM(){
if( dr(this.delta).z != 0){
if(Number.isNaN(dr(this.delta).x)){
return 0;
}
return ( dr(this.delta).x / dr(this.delta).z );
}else{return 0;}
}
dxdzC(){ //y = mx + c //c = y - mx
return ( dr(this.start).x - (this.dxdzM() * dr(this.start).z) );
}

printouttheparametricformat(){
printoutt(dydxM ${this.dydxM()} <br> dydxC ${this.dydxC()} <br> yz ${this.dydzM()} <br> yz ${this.dydzC()} <br> zx ${this.dzdxM()} <br> zx ${this.dzdxC()} <br> zy ${this.dzdyM()} <br> zy ${this.dzdyC()} <br> xy ${this.dxdyM()} <br> xy ${this.dxdyC()} <br> xz ${this.dxdzM()} <br> xz ${this.dxdzC()} <br>);

}

InfinityResolveByX(ecs = 0){
let vidid = pushStackTrace("RefLine.findPointOnInfLineByX");
var ny, nz, nt;
ny = 0; nz = 0; nt = 0;
if(dr(this.delta).x != 0){
//printoneline(<br>27/7/2022 ${ecs}<br>);
ny =(this.dydxM() * ecs) + this.dydxC();
nz =(this.dzdxM() * ecs) + this.dzdxC(); // should i do duration/x?
let dtdxM = dr(this.delta).t.duration / dr(this.delta).x;
let dtdxC = dr(this.start).t.duration - (dtdxM * dr(this.start).x );
nt = (ecs * dtdxM) + dtdxC;

 }

let r1 = new RefDot(ecs, ny, nz, nt); //printoutt(inside ${r1.regind} x:${ecs}, y:${ny}, z: ${nz}, t: ${nt});
popStackTrace(vidid);
return r1.regind;
}
InfinityResolveByY(wai){
let vidid = pushStackTrace("RefLine.findPointOnInfLineByY");
var nx, nz, nt;
nx = 0; nz = 0; nt = 0;
if(dr(this.delta).y != 0){
nx = (this.dxdyM() * wai) + this.dxdyC();
nz = (this.dzdyM() * wai) + this.dzdyC();
// should i do duration/x?
let dtdyM = dr(this.delta).t.duration / dr(this.delta).y;
let dtdyC = dr(this.start).t.duration - (dtdyM * dr(this.start).y );
nt = (wai * dtdyM) + dtdyC;

 }
let r1 = new RefDot(nx, wai, nz, nt);
popStackTrace(vidid);

return r1.regind;

}
InfinityResolveByZ(zee){
let vidid = pushStackTrace("RefLine.findPointOnInfLineByZ");
var nx, ny, nt;
nx = 0; ny = 0; nt = 0;
if(dr(this.delta).z != 0){
nx = (this.dxdzM() * zee) + this.dxdzC();
ny = (this.dydzM() * zee) + this.dydzC();
// should i do duration/x?
let dtdzM = dr(this.delta).t.duration / dr(this.delta).z;
let dtdzC = dr(this.start).t.duration - (dtdzM * dr(this.start).z );
nt = (zee * dtdzM) + dtdzC;
}
let r1 = new RefDot(nx, ny, zee, nt);popStackTrace(vidid);
return r1.regind;
}

isColinear(quedot){
quedot = dr(this.start).checkarg(quedot);
var AnsDot;
if( dr(this.delta).x != 0){
AnsDot = this.InfinityResolveByX(dr(quedot).x);
}else if( dr(this.delta).y != 0){
AnsDot = this.InfinityResolveByY(dr(quedot).y);
}else if( dr(this.delta).z != 0){
AnsDot = this.InfinityResolveByZ(dr(quedot).z);
}else{return 0;}

return dr(quedot).isSpatiallyEquivalent(AnsDot);
}

FiniteResolveByX(ecs){
let vidid = pushStackTrace("RefLine.FiniteResolveByX");
ecs = Number.parseFloat(ecs).toFixed(19);

	if( this.isXInLineRange(ecs) ){

let retv = this.Euclid2ndPostulateByX(ecs);
//printoutt("inside finiteresolvebyX" + JSON.stringify(dr(retv)));
popStackTrace(vidid);
return retv;
}else{popStackTrace(vidid);return -1; }
}
FiniteResolveByY(wai){
let vidid = pushStackTrace("RefLine.FiniteResolveByY");

  if( this.isYInLineRange(wai) ){ 

let retv = this.Euclid2ndPostulateByY(wai);
popStackTrace(vidid);
return retv.regind;
} else{popStackTrace(vidid);return -1;}
}
FiniteResolveByZ(zee){
let vidid = pushStackTrace("RefLine.FiniteResolveByY");
if( this.isZInLineRange(zee) ){
let retv = this.Euclid2ndPostulateByZ(zee);
popStackTrace(vidid);
return retv.regind;
} else{popStackTrace(vidid);return -1;}
}

CreatePlaneWithThirdDot(poin3){
poin3 = dr(this.start).checkarg(poin3);
let e1 = new RefLine(poin3, this.start);
let e2 = new RefLine(poin3, this.end);
let x4 = ((dr(e1.delta).y * dr(e2.delta).z) - (dr(e1.delta).z * dr(e2.delta).y));
let y4 = ((dr(e1.delta).z * dr(e2.delta).x) - (dr(e1.delta).x * dr(e2.delta).z));
let z4 = ((dr(e1.delta).x * dr(e2.delta).y) - (dr(e1.delta).y * dr(e2.delta).x));
var planarvector = new RefDot(x4,y4,z4);
planarvector.setConstant(planarvector.dotproduct(poin3));
e1.rubbish();
e2.rubbish();
return planarvector.regind;
}

InfinityIntersection(aline){
let vidid = pushStackTrace("RefLine.InfinityINtersection");
aline = this.checkarg(aline);
if(!(Number.isNaN(this.dydxM())) && !(Number.isNaN(this.dydxM())) && (this.dydxM() != lr(aline).dydxM())){
// printoutt("not YX paralel");
let dem = lr(aline).dydxM() - this.dydxM();
// printoneline(<br>27/7/2022 ${dem});
let num = this.dydxC() - lr(aline).dydxC();
// printoneline(<br>27/7/2022 ${num});
popStackTrace(vidid);
return this.InfinityResolveByX( (num/dem));
}else if(!(Number.isNaN(this.dzdxM())) && !(Number.isNaN(this.dzdxM())) && (this.dzdxM() != lr(aline).dzdxM())){
// printoneline("not ZX paralel");
let dem = lr(aline).dzdxM() - this.dzdxM();
let num = this.dzdxC() - lr(aline).dzdxC();

	popStackTrace(vidid);
	return this.InfinityResolveByX( (num/dem));
}else if(!(Number.isNaN(this.dxdzM())) && !(Number.isNaN(this.dxdzM())) && (this.dxdzM() != lr(aline).dxdzM())){

// printoneline("not xz paralel");
let dem = lr(aline).dxdzM() - this.dxdzM();
let num = this.dxdzC() - lr(aline).dxdzC();

	popStackTrace(vidid);
	return this.InfinityResolveByZ( (num/dem));
}else if(!(Number.isNaN(this.dydzM())) && !(Number.isNaN(this.dydzM())) && (this.dydzM() != lr(aline).dydzM())){

// printoneline("not yz paralel");
let dem = lr(aline).dydzM() - this.dydzM();
let num = this.dydzC() - lr(aline).dydzC();

	popStackTrace(vidid);
	return this.InfinityResolveByZ( (num/dem));
}else if(!(Number.isNaN(this.dzdyM())) && !(Number.isNaN(this.dzdyM())) && (this.dzdyM() != lr(aline).dzdyM())){

// printoneline("not ZY paralel");
let dem = lr(aline).dzdyM() - this.dzdyM();
let num = this.dzdyC() - lr(aline).dzdyC();

	popStackTrace(vidid);
	return this.InfinityResolveByY( (num/dem));

}else if(!(Number.isNaN(this.dxdyM())) && !(Number.isNaN(this.dxdyM())) && (this.dxdyM() != lr(aline).dxdyM())){

// printoutt("not XY paralel");
let dem = lr(aline).dxdyM() - this.dxdyM();
let num = this.dxdyC() - lr(aline).dxdyC();

	popStackTrace(vidid);
	return this.InfinityResolveByY( (num/dem));
}else{

this.printouttheparametricformat();

	popStackTrace(vidid);
	return -1;}	

}
Finite3DIntersection(aline){
let vidid = pushStackTrace("RefLine.Finite3Dintersection");
aline = this.checkarg(aline);
var verificationplane = this.CreatePlaneWithThirdDot(lr(aline).start);
let flatflag1 = dr(verificationplane).isPointOnPlane(lr(aline).end);

if(flatflag1){
var an3 = this.InfinityIntersection(aline);
//gets to here;
//
if(an3 == 42){globalflag91 = 1;}else{globalflag91 = 0;}
var an2 = this.FiniteResolveByX(dr(an3).x);
if(an2 == -1){
an2 = this.FiniteResolveByY(dr(an3).y);
}
if(an2 == -1){
an2 = this.FiniteResolveByZ(dr(an3).z);
}
// printoutt(here is an2 ${an2} foran3 was ${an3});
// printoutt("gets to here" + JSON.stringify(dr(an3)) + "
" + JSON.stringify(this) + "
" + JSON.stringify(dr(this.start)) + "
"+JSON.stringify(dr(this.end)) + "
");
popStackTrace(vidid);

return an2;
}else{
// printoneline("
================
=============
==================
===============
===============
===============
=======================
============");
}
popStackTrace(vidid);

return -1;

}

CreateNormalPlaneUsingPoint(ecs){
let vidid = pushStackTrace("RefLine.createNormalplaneusingpoint");
// On the line, given a point,
// the normal plane can be computed.
let poin = checkdotarg(ecs);
//let poin = this.FiniteResolveByX(ecs);

if(poin != -1){
dr(poin).singlefactormultiply(-1);
//
var PerpePlane = dr(this.delta).copyOfDot();
let vade = dr(PerpePlane).dotproduct(poin);
vade *= -1;
dr(PerpePlane).setConstant(vade);
dr(poin).rubbish();
popStackTrace(vidid);
return PerpePlane;
}
popStackTrace(vidid);
return -1;
}
CreateNormalPlaneUsingX(ecs = 0){
let vidid = pushStackTrace("RefLine.createNormalPlaneUsingX");
// On the line, given a point,
// the normal plane can be computed.
//ecs = checkpointarg(ecs);
//printoutt(inside createnormalplane, arg is ${ecs});
var poin = this.FiniteResolveByX(ecs);
//XXX ISSUE HERE IS THAT poin is Co-linear...
//printoutt("HERE" + JSON.stringify(dr(poin)));
//printoutt(JSON.stringify(poin));
poin = checkdotarg(poin);
if(poin != -1){
dr(poin).singlefactormultiply(-1);
//
var PerpePlane = dr(this.delta).copyOfDot();
let vade = dr(PerpePlane).dotproduct(poin);
vade *= -1;
dr(PerpePlane).setConstant(vade);
dr(poin).rubbish();
popStackTrace(vidid);
return PerpePlane;
}else{poin = this.start;
popStackTrace(vidid);
return -1;
}
}

findPointOnCartesianPlaneFromXY( plan, ecs = 0, wai = 0){
//Appendage Function (needs a library)
let vidid = pushStackTrace("RefLine.CreatePointOnCartesianINFINITEPlaneFromXY");
plan = dr(this.start).checkarg(plan);
if(plan == -1){return -1;}
ecs *= dr(plan).x;
wai *= dr(plan).y;
let zee = dr(plan).c + ecs + wai;
if(dr(plan).x != 0){ecs /= dr(plan).x;}
if(dr(plan).y != 0){wai /= dr(plan).y;}
if(dr(plan).z != 0){zee /= dr(plan).z;}else{zee = 0;}
var rpd = new RefDot(ecs, wai, zee);
popStackTrace(vidid);
return rpd.regind;

}
findPointOnCartesianPlaneFromXZ( plan, ecs = 0, zee = 0){
//Appendage Function (needs a library)
let vidid = pushStackTrace("RefLine.CreatePointOnCartesianINFINITEPlaneFromXZ");
plan = dr(this.start).checkarg(plan);
if(plan == -1){return -1;}
ecs *= dr(plan).x;
zee *= dr(plan).z;
let wai = dr(plan).c + ecs + zee;
if(dr(plan).x != 0){ecs /= dr(plan).x;}
if(dr(plan).y != 0){wai /= dr(plan).y;}else{wai = 0;}
if(dr(plan).z != 0){zee /= dr(plan).z;}
var rpd = new RefDot(ecs, wai, zee);
popStackTrace(vidid);
return rpd.regind;
}
findPointOnCartesianPlaneFromYZ( plan, sky = 0, zee = 0){
//Appendage Function (needs a library)
let vidid = pushStackTrace("RefLine.CreatePointOnCartesianINFINITEPlaneFromYZ");
plan = dr(this.start).checkarg(plan);
if(plan == -1){return -1;}
sky *= dr(plan).y;
zee *= dr(plan).z;
let EGZ = dr(plan).c + sky + zee;
if(dr(plan).y != 0){sky /= dr(plan).y;}
if(dr(plan).x != 0){EGZ /= dr(plan).x;}else{EGZ = 0;}
if(dr(plan).z != 0){zee /= dr(plan).z;}
var rpd = new RefDot(EGZ, sky, zee);
popStackTrace(vidid);
return rpd.regind;
}

findEquilateralHeight(EdgeLength = 100, baselength = 50){
let vidid = pushStackTrace("RefLine.findequilateralheight");
// x2 + y2 = h2; h2 - x2 = y2
//printoneline(arguments are ${EdgeLength} and ${baselength});
let hyp = EdgeLength * EdgeLength;
let Adj = baselength * baselength;
//printoneline(hyp is ${hyp} and adj is ${Adj});
let opp = hyp - Adj;
let height = Math.sqrt(opp);
// printoneline(height is ${height});
popStackTrace(vidid);
return height;
}

CrossProduct3D(aline){
aline = checklinearg(aline);

let Ion, jon, kon;
//The cross product is of the component vectors of a line, since a line sits ni space. between two points. (Two points cogently in space.)
// i j k i = bf - ec
//this// a b c j = cd - fa
//aline/ d e f k = ae - db

ion = dr(lr(aline).delta).z * dr(this.delta).y - dr(lr(aline).delta).y * dr(this.delta).z;
jon = dr(lr(aline).delta).x * dr(this.delta).z - dr(lr(aline).delta).z * dr(this.delta).x;
kon = dr(lr(aline).delta).y * dr(this.delta).x - dr(lr(aline).delta).x * dr(this.delta).y;

var rd = new RefDot(ion, jon, kon);
return rd.regind;

}

}

function PositiveLine(leng){
var d1 = new RefDot(0,0,0);
var d2 = new RefDot(10,10,10);
var r1 = new RefLine(d1,d2);
r1.changeDistance(leng);
return r1.regind;
}

function checklinearg(argx){
if(argx instanceof RefLine){
return argx.regind;
}else{
if(argx < linreg.first.length){
if(lr(argx) != -1){
return argx;}
}else{ }
}
return -1;
}

class TriangleRegister {

constructor (){
this.first = [];
this.second = [];
}

printdump(ind = 0){
printoutt( In Triangle Register There are ${this.first.length} first elements, and ${this.second.length} second elements.);
if(ind >0){
printoutt("FIRST
" + JSON.stringify(this.first));
printoutt("SECOND
" + JSON.stringify(this.second));
}
}
pushtriangle(enru){
let vidid = pushStackTrace("TriangleRegister.pushline");
if(enru instanceof RefTriangle){

let va2 = this.matchtriangle(enru);

if(va2 == -1){
this.second.push(enru);
this.first.push( (this.second.length - 1) );
enru.regind = this.first.length - 1;

}else{
enru.regind = va2;
}
}
//this.printdump();
popStackTrace(vidid);
return (enru.regind);
}

poptriangle(ind){
let vidid = pushStackTrace("triangleRegister.popnum");
if((ind < this.first.length) && (ind > (0 - this.first.length))){
var memx1 = this.first[ind];
if(memx1 != -1){
this.second.splice((memx1),1);
for(let ite1 = 0; ite1 < this.first.length; ite1++){
if(this.first[ite1] > memx1){
this.first[ite1]--;
}
}
this.first[ind] = -1;
}
}
popStackTrace(vidid);
}

fetchtriangle(ind){
let vidid = pushStackTrace("TriangleRegister.fetchtriangle");
if((ind >= 0) && (ind <= this.first.length)){
let rd = this.first[ind];
if(rd != -1){//assume the value is always a cogent index.
var sd = this.second[rd];
popStackTrace(vidid);
return sd;
}
}
//printoutt(XXX Out Of Bounds Fetchtriangle(${ind});
popStackTrace(vidid);
return -1;

}

matchtriangle(arc){
//finds lines which are purposely created using the same dots.
if(arc instanceof RefTriangle){
// if(artic.AllowDuplication == 1){return -1;}
for(let it1 = 0; it1 < this.first.length; it1++){
let va1 = this.first[it1];
if(va1 != -1){
if(
( ( arc.points[0] == this.second[va1].points[0])
&& ( arc.points[1] == this.second[va1].points[1]) && ( arc.points[2] == this.second[va1].points[2]))
|| ( ( arc.points[0] == this.second[va1].points[0])
&& ( arc.points[1] == this.second[va1].points[2]) && ( arc.points[2] == this.second[va1].points[1]))
|| ( ( arc.points[0] == this.second[va1].points[1])
&& ( arc.points[1] == this.second[va1].points[2]) && ( arc.points[2] == this.second[va1].points[0]))
|| ( ( arc.points[0] == this.second[va1].points[1])
&& ( arc.points[1] == this.second[va1].points[0]) && ( arc.points[2] == this.second[va1].points[2]))
|| ( ( arc.points[0] == this.second[va1].points[2])
&& ( arc.points[1] == this.second[va1].points[1]) && ( arc.points[2] == this.second[va1].points[0]))
|| ( ( arc.points[0] == this.second[va1].points[2])
&& ( arc.points[1] == this.second[va1].points[0]) && ( arc.points[2] == this.second[va1].points[1]))

){//match found;  
		//	this.printdump();
		
		return it1;
			}
		}
	}
}
return -1;

}

}
//It is possible to put these inside a CANVAS
var trireg = new TriangleRegister();
function tr (indx){
return trireg.fetchtriangle(indx);
}

var granularity = 2;//XXX make INLINE
class RefTriangle{
//𐤐ְּ𐤍ֵ֣𐤉
//𐤌ַ𐤉ִ𐤌
constructor(DA, DB, DC){
let vidid = pushStackTrace("RefTriangle.constructor");
//Do u want to check if regind or instanceofDOT?
this.classtype = "reftriangle";
DA = checkdotarg(DA);
DB = checkdotarg(DB);
DC = checkdotarg(DC);
dr(DA).timeaccruer++;
dr(DB).timeaccruer++;
dr(DC).timeaccruer++;
this.points = [DA, DB, DC];
this.regind = 0;
this.timeaccruer = 0;
//this.reconstructtriangle(this.points);
this.center;
this.averagecenter;
this.colour = "#000000";
this.lines = [];
this.angles = [];
//this.setCenter();
this.plane = [];
this.planearea = 0;
//this.lawofcosines();
//this.findArea();
this.CartesianPlane;
this.Normal;// = this.createNormalVector(1);
//this.createCartesianPlaneEquation();
this.refresh();

popStackTrace(vidid);

}
refresh(){
//if(this.timeaccruer != 0){ this.rubbish(0);}
if(this.regind == 0){
this.regind = trireg.pushtriangle(this);}
this.reconstructtriangle(this.points);
this.setCenter();
this.lawofcosines();
this.findArea();
this.Normal = this.createNormalVector(1);
this.createCartesianPlaneEquation();

}

reconstructtriangle(dots){
let vid = pushStackTrace("RefTriangleTwo.reconstructtriangle");
if(this.lines.length == 3){this.rubbish(1);}
let l1 = new RefLine(this.points[0], this.points[1]);
let l2 = new RefLine(this.points[1], this.points[2]);
let l3 = new RefLine(this.points[0],this.points[2]);
this.lines =[l1.regind, l2.regind, l3.regind];
l1.timeaccruer++;
l2.timeaccruer++;
l3.timeaccruer++;
l1.colour = this.colour;
l2.colour = this.colour;
l3.colour = this.colour;
this.angles = [0,0,0];
this.AS = this.lines[1];
this.BS = this.lines[2];
this.CS = this.lines[0];

popStackTrace(vid);

}
print(ver = 1){
if(ver > 0){
printoutt( This triangle ${this.regind} has dots ${this.points[0]},${this.points[1]},${this.points[2]},<br> sides ${lr(this.AS).distance}, ${lr(this.BS).distance}, ${lr(this.CS).distance},<br> and angles ${radtodeg(this.AA)}, ${radtodeg(this.BA)}, ${radtodeg(this.CA)}<br> And an area of ${this.Area});
}
if(ver > 1){
printoneline("
first point
");
dr(this.points[0]).print();
printoneline("
second point
");
dr(this.points[1]).print();
printoneline("
third point
");
dr(this.points[2]).print();

if(dr(this.center) instanceof RefDot){
printoneline("
central point
"); dr(this.center).print();
}
if(dr(this.averagecenter) instanceof RefDot) {
printoneline("
Average Central Point point
");
dr(this.averagecenter).print();
}

}
}
rubbish(deg = 2){
//deg = 0 remove self (Plane + Normal)
//deg = 1 remove self and 3 edges
//deg = 2 remove self, edges, vertices

if(deg > 0){
lr(this.AS).timeaccruer--;
lr(this.BS).timeaccruer--;
lr(this.CS).timeaccruer--;
lr(this.AS).rubbish(0);
lr(this.BS).rubbish(0);
lr(this.CS).rubbish(0);
}

if(deg > 1){
dr(this.points[0]).timeaccruer--;
dr(this.points[1]).timeaccruer--;
dr(this.points[2]).timeaccruer--;
dr(this.points[0]).rubbish();
dr(this.points[1]).rubbish();
dr(this.points[2]).rubbish();
}

//this.timeaccruer--;
if(dr(this.CartesianPlane) instanceof RefDot){
dr(this.CartesianPlane).timeaccruer--;
dr(this.CartesianPlane).rubbish();
}
if(dr(this.center) instanceof RefDot){
dr(this.center).timeaccruer--;
dr(this.center).rubbish();
}
if(this.timeaccruer == 0){
trireg.poptriangle(this.regind);
}

}

lawofcosines ( ) {
let vidid = pushStackTrace("RefTriangleTwo.lawofcosines");
let Aside = lr(this.AS).distance;
let Bside = lr(this.BS).distance;
let Cside = lr(this.CS).distance;
let o1 = 0;
//work out 3
o1 = (Cside * Cside) - (Aside * Aside) - (Bside * Bside);
o1 /= (-2 * Aside * Bside);
this.angles[2] = Math.acos(o1);
//work out 2
o1 = (Bside * Bside) - (Cside * Cside) - (Aside * Aside);
o1 /= (-2 * Cside * Aside);
this.angles[1] = Math.acos(o1);
//work out 1
o1 = (Aside * Aside) - (Cside * Cside) - (Bside * Bside);
o1 /= (-2 * Bside * Cside);
this.angles[0] = Math.acos(o1);
this.AA = this.angles[0]; this.BA = this.angles[1]; this.CA = this.angles[2];

popStackTrace(vidid);

}

findArea () {
this.Area = 0.5 * lr(this.AS).distance * lr(this.BS).distance * Math.sin(this.CA);
}

setCenter(){
	 let vidid =	 pushStackTrace("RefTriangle.setCEnter");
/*	
	if(dr(this.center) instanceof RefDot){
		 dr(this.center).timeaccruer--;
	 dr(this.center).rubbish();
	 }

*/
var il1 = new RefLine(dr(lr(this.lines[0]).center), dr(this.points[this.findExcludedDot(0)]));
// DFS.depthdraw(il1);
var il2 = new RefLine(
dr(lr(this.lines[1]).center),
dr(this.points[this.findExcludedDot(1)]));

	var inter1 = il2.InfInt3(il1);
	if(inter1 == -1){
		il1.rubbish(0);
		il1 =   new RefLine( 
	dr(lr(this.lines[2]).center), 
	dr(this.points[this.findExcludedDot(2)]))
		inter1 = il2.InfInt3(il1);
	}


	if(dr(this.center) instanceof RefDot){
	dr(this.center).resetxyzt( inter1);
	dr(inter1).rubbish();
	}else if(dr(inter1) != -1) {
	//	printoutt(`========WHY is inter1 a random nothing? ===============${JSON.stringify(dr(inter1))}==================${JSON.stringify(inter1)}=================`);
	this.center = inter1;
	dr(this.center).timeaccruer++;
	}else{
this.makePlanarGraphOfTriangle();
this.rubbishplane();
this.center = this.averagecenter;		
	}
		
il2.rubbish(0);
il1.rubbish(0);
popStackTrace(vidid);
}

createNormalVector(orderoflines = 1){
// Normal is line in form of delta(xyz)

//Add this.Normal to any point on the triangle.

	let vidid =	 pushStackTrace("RefTriangle.findNormalVector");
//XXX is necessary?  orderoflines = [-2,-1,0,1,2,3]
//if orderoflines == NOPE 

let v1, v2;
switch(orderoflines){
case -2:
v1 = lr(this.lines[2]);
v2 = lr(this.lines[1]);
break;
case -1:
v1 = lr(this.lines[1]);
v2 = lr(this.lines[0]);
break;
case 0:
v1 = lr(this.lines[0]);
v2 = lr(this.lines[2]);
break;
case 1:
v1 = lr(this.lines[0]);
v2 = lr(this.lines[1]);
break;
case 2:
v1 = lr(this.lines[1]);
v2 = lr(this.lines[2]);
break;
default:
v2 = lr(this.lines[2]);
v1 = lr(this.lines[0]);
break;
}
/*
if( dr(this.Normal) instanceof RefDot){
dr(this.Normal).timeaccruer--;
dr(this.Normal).rubbish();
}*/

let x2s3 = new RefDot((( dr(v1.delta).y * dr(v2.delta).z) - (dr(v1.delta).z * dr(v2.delta).y)),
((dr(v1.delta).z * dr(v2.delta).x) - (dr(v1.delta).x * dr(v2.delta).z)),
((dr(v1.delta).x * dr(v2.delta).y) - (dr(v1.delta).y * dr(v2.delta).x)), dr(this.center).t);
if(dr(this.Normal) instanceof RefDot){
dr(this.Normal).resetxyzt(x2s3.regind);
x2s3.rubbish();}else{this.Normal = x2s3.regind; x2s3.timeaccruer++;}
popStackTrace(vidid);
return this.Normal;
}

createCartesianPlaneEquation(){
//@param@ In form of U.x(i) + U.y(j) + U.z(k) = U.c
let vidid = pushStackTrace("RefTriangle.findPlaneCartesianEquation");
//step1 first find the r = normal by the determinant
let x22 = dr(this.createNormalVector());
//step2 then find the scalar dot product
// r * (x,y,z) = r * point
if(dr(this.CartesianPlane) instanceof RefDot){
dr(this.CartesianPlane).rubbish();
}
this.CartesianPlane = x22.copyOfDot();
let con = (x22.x * dr(this.points[0]).x) + (x22.y * dr(this.points[0]).y) + (x22.z * dr(this.points[0]).z);
//3 xi + yj + zk = c; xi + yj + zk - c = 0
dr(this.CartesianPlane).setConstant(con);
popStackTrace(vidid);
}

CreatePointOnInfCartesianPlaneFromXY(ecs = 0, wai = 0){
let vidid = pushStackTrace("RefTriangle.CreatePointOnCartesianINFINITEPlaneFromXY");
this.createPlaneCartesianEquation();
ecs *= dr(this.CartesianPlain).x;
wai *= dr(this.CartesianPlain).y;
let zee = dr(this.CartesianPlain).c - ecs - wai;
let Nd = new RefDotTwo(ecs, wai, zee);
popStackTrace(vidid);
return Nd.regind;
}

CreatePointOnInfCartesianPlaneFromYZ(wai = 0, zee = 0){
// xi + yj + zk = c; c - yj - zk = xi
let vidid = pushStackTrace("RefTriangleTwo.CreatePointOnCartesianINFINITEPlaneFromYZ");
this.createPlaneCartesianEquation();
zee *= dr(this.CartesianPlain).z;
wai *= dr(this.CartesianPlain).y;
let ecs = dr(this.CartesianPlain).c - zee - wai;
let Nd = new RefDot(ecs, wai, zee);
popStackTrace(vidid);
return Nd.regind;
}

CreatePointOnInfCartesianPlaneFromXZ(ecs = 0, zee = 0){
// xi + yj + zk = c; c - xi - zk = yj
let vidid = pushStackTrace("RefTriangle.CreatePointOnINFINITECartesianPlaneFromXZ");
this.createPlaneCartesianEquation();
zee *= dr(this.CartesianPlain).z;
ecs *= dr(this.CartesianPlain).x;
let wai = dr(this.CartesianPlain).c - zee - ecs;
let Nd = new RefDot(ecs, wai, zee);
popStackTrace(vidid);
return Nd.regind;
}

findExcludedDot (IncludedLineIndex){
//@ Info:: Each Line has 2 dots thus the triangle's third dot is excluded from any line
//purpose@ XXX
//inputs @
//outputs@
switch(IncludedLineIndex){
case 0:
return 2;
break;
case 1:
return 0;
break;
case 2:
return 1;
break;
default:
printoutt("=-broken in findExcludedDot-=");return 0;
}
}

makePlanarGraphOfTriangle () {

let vidid = pushStackTrace("RefTriangle.make3DPlaneOfTriangle");
//xxx NEED COMMENTARY
let baseline = lr(this.lines[0]);
let thirddot = this.findExcludedDot(0);
let onethree = new RefLine(baseline.start, this.points[thirddot]);
let twothree = new RefLine(baseline.end, this.points[thirddot]);
//work out the ratio between the onethree and twothree so that onethree increments by o and twothree increments by p .
let M13; let M23;
if(twothree.distance > onethree.distance){
M13 = granularity * twothree.distance / onethree.distance;
M23 = granularity;
}else{
M23 = granularity * onethree.distance / twothree.distance;
M13 = granularity;
}

var asfd = new RefDot(0,0,0);
let avecount = 0;

let flag23 = 1; let flag13 = 1;
let dist23 = 0; let dist13 = 0;
let bounceflag = 1;
let bouncedflag = 0;
let point1 = dr(baseline.start);
let point2 = dr(baseline.end);

while(flag23 || flag13){

let ln1 = new RefLine(point1, point2);
asfd.addDot(ln1.center);
avecount++;
//printoneline(<br> ${asfd.x} over ${avecount} is ${asfd.x / avecount});
ln1.colour = this.colour;
this.plane.push(ln1.regind);
this.planearea += ln1.distance;
if(dist23 > twothree.distance){
flag23 = 0;bounceflag = 0;bouncedflag = 13;}
if(dist13 > onethree.distance){
flag13 = 0;bounceflag = 0;bouncedflag = 23;}
//shouldbounce if both flags 1,
//shouldn't bounce if either flag 0 .
if(bounceflag == 1){
point1 = point2;
if(bouncedflag == 1){dist23+=M23;
point2 = twothree.crawlDistanceFromStart(dist23);
bouncedflag = 0;
}else{dist13+=M13; bouncedflag = 1;
point2 = onethree.crawlDistanceFromStart(dist13);
}
}else{
if(bouncedflag == 13){dist13+=M13;
point2 = onethree.crawlDistanceFromStart(dist13);
}
if(bouncedflag == 23){
dist23+= M23;
point2 = twothree.crawlDistanceFromStart(dist23);
}
}
}//while

asfd.singlefactormultiply(1/avecount);
this.averagecenter = asfd.copyOfDot();
asfd.rubbish();

popStackTrace(vidid);
}

rubbishplane(){
	for(let x3 = this.plane.length-1; x3 > 0 ; x3--){

if(lr(this.plane[x3]) instanceof RefLine){
lr(this.plane[x3]).rubbish(1);
}else{
// printoutt(NOT A LINE = ${this.plane[x3]} FOUND IN THE PLANE???);
}
this.plane.pop();
}
}

findEquilateralHeight(EdgeLength = 100, baselength = 50){
// x2 + y2 = h2; h2 - x2 = y2
let hyp = EdgeLength * EdgeLength;
let Adj = baselength * baselength;
let opp = hyp - Adj;
let height = Math.sqrt(opp);
return height;
}

changeColour(kak){
this.colour = kak;
this.refresh();
}

draw(TCF = globalviewerframe){
TCF.depthdraw(lr(this.lines[0]));
TCF.depthdraw(lr(this.lines[1]));
TCF.depthdraw(lr(this.lines[2]));
}

}

function checktrianglearg (ard){
if(ard instanceof RefTriangle){
return ard.regind;
}else{
if(tr(ard) instanceof RefTriangle){
return ard;
}else{
// is there another condition here?
return -1;
}
}
}

// 𐤕ְּ𐤄𐤅ֹ𐤌
class RefTetrahedron {

constructor (BaseLine ) {
let DFS = globalviewerframe;
let vidid = pushStackTrace("RefTetrahedron.constructor");
if(BaseLine instanceof RefLine){
this.points = [];
this.lines = [];
this.center = -1;
this.faces = [];
this.averagecenter = 0;
this.facesexcludeddot = [];
this.facestruts = [];
this.edgestruts = [];
this.landface = [];
this.skyedges = [];
// this.points.push(BaseLine.start);
//this.lines[0] = checklinearg(BaseLine);
this.points[0] = BaseLine.start;
this.points[1] = BaseLine.end;

//printoutt("HERE IT IS 8210");
this.faces[0] = this.createEquilateralTriangleWithXY(BaseLine, 1 , 1 );
if(dr(tr(this.faces[0]).center) == -1){alert("Center of Triangle failing");return;}
//tr(this.faces[0]).makePlanarGraphOfTriangle();
//tr(this.faces[0]).print(2);
this.points[2] = tr(this.faces[0]).points[2];

//printoutt("HERE IT IS 8310");
this.points[3] = this.findFourthDotFromFace(this.faces[0]);

dr(this.points[0]).timeaccruer++;
dr(this.points[1]).timeaccruer++;
dr(this.points[2]).timeaccruer++;
dr(this.points[3]).timeaccruer++;

tr(this.faces[0]).rubbish(0);
//printoutt("HERE IT IS 8381");
this.createFourFacesFromFourPoints();
//printoutt("HERE IT IS 8382");
this.createSixEdgesFromFourFaces();
//printoutt("HERE IT IS 8383");
this.setCenter();
this.findAverageCenter();

}
popStackTrace(vidid);
}

print(){
printoutt(number of faces ${this.faces.length} number of lines ${this.lines.length});
lr(this.lines[0]).print(2);
lr(this.lines[1]).print(2);
lr(this.lines[2]).print(2);
lr(this.lines[3]).print(2);

}

draw(DFS = globalviewerframe){

}

createEquilateralTriangleWithXY(BaseLine, ecs = 0, wai = 0){
let vidid = pushStackTrace("RefTetrahedron.createEquilateralTriangleWithXY");

BaseLine = checklinearg(BaseLine);
if(BaseLine == -1){return -1;}

let sparepoint = dr(lr(BaseLine).center).copyOfDot();
let NormPlan = lr(BaseLine).CreateNormalPlaneUsingPoint(sparepoint);
if(NormPlan == -1){return -1;}

let PerpenPoint = lr(BaseLine).findPointOnCartesianPlaneFromXY(NormPlan,ecs, wai);

dr(NormPlan).rubbish();

let spareline1 = new RefLine(lr(BaseLine).center, PerpenPoint);
spareline1.changeDistanceChangeEnd( lr(BaseLine).findEquilateralHeight(lr(BaseLine).distance, lr(BaseLine).distance/2));
let retval = new RefTriangle(lr(BaseLine).start, lr(BaseLine).end, spareline1.end);
spareline1.rubbish(0);
popStackTrace(vidid);
return retval.regind;

}

findFourthDotFromFace(FaceR){
FaceR = checktrianglearg(FaceR);

let CC = dr(tr(FaceR).center).copyOfDot();
dr(CC).addDot(tr(FaceR).Normal);

let bl = new RefLine(tr(FaceR).center, tr(FaceR).points[1]);
let mll = bl.findEquilateralHeight(lr(tr(FaceR).lines[0]).distance, bl.distance);
let ml = new RefLine(tr(FaceR).center, CC);

ml.changeDistanceChangeEnd(mll);

return ml.end;

}

createFourFacesFromFourPoints(){
if(this.points.length != 4){return -1;}
if(0 == (
(dr(this.points[0]) instanceof RefDot) &&
(dr(this.points[1]) instanceof RefDot) &&
(dr(this.points[2]) instanceof RefDot) &&
(dr(this.points[3]) instanceof RefDot) )){return -1;}

//Uses the Single-Thread method, two wrap around the outside. Assumes a granularity creep of one.
//0 = A B C
//1 = C A D
//2 = D C B
//3 = B D A
let T1 = new RefTriangle(this.points[0], this.points[1], this.points[2]);
this.faces[0] = T1.regind;
this.facesexcludeddot[0] = 3;
T1 = new RefTriangle(this.points[2], this.points[0], this.points[3]);
this.faces[1] = T1.regind;
this.facesexcludeddot[1] = 1;
T1 = new RefTriangle(this.points[3], this.points[2], this.points[1]);
this.faces[2] = T1.regind;
this.facesexcludeddot[2] = 0;
T1 = new RefTriangle(this.points[1], this.points[3], this.points[0]);
this.faces[3] = T1.regind;
this.facesexcludeddot[3] = 2;
}

createSixEdgesFromFourFaces(){
this.lines[0] = tr(this.faces[0]).lines[0];
this.lines[1] = tr(this.faces[2]).lines[0];
this.lines[2] = tr(this.faces[1]).lines[0];
this.lines[3] = tr(this.faces[3]).lines[0];

this.lines[4] = tr(this.faces[0]).lines[1];
this.lines[5] = tr(this.faces[1]).lines[1];

}

createFaceStruts(){
let v1 = new RefLine(tr(this.faces[0]).center, this.points[this.facesexcludeddot[0]]);
this.facestruts[0] = v1.regind;
v1 = new RefLine(tr(this.faces[1]).center, this.points[this.facesexcludeddot[1]]);
this.facestruts[1] = v1.regind;
v1 = new RefLine(tr(this.faces[2]).center, this.points[this.facesexcludeddot[2]]);
this.facestruts[2] = v1.regind;
v1 = new RefLine(tr(this.faces[3]).center, this.points[this.facesexcludeddot[3]]);
this.facestruts[3] = v1.regind;
}

rubbishFaceStruts(){
lr(this.facestruts[0]).rubbish(0);
lr(this.facestruts[1]).rubbish(0);
lr(this.facestruts[2]).rubbish(0);
lr(this.facestruts[3]).rubbish(0);
this.facestruts.pop();
this.facestruts.pop();
this.facestruts.pop();
this.facestruts.pop();

}

createEdgeStruts(){
let v1 = new RefLine(lr(this.lines[0]).center, lr(this.lines[1]).center);
this.edgestruts[0] = v1.regind;
v1 = new RefLine(lr(this.lines[2]).center, lr(this.lines[3]).center);
this.edgestruts[1] = v1.regind;
v1 = new RefLine(lr(this.lines[4]).center, lr(this.lines[5]).center);
this.edgestruts[2] = v1.regind;
}

rubbishEdgeStruts(){
lr(this.edgestruts[0]).rubbish(0);
lr(this.edgestruts[1]).rubbish(0);
lr(this.edgestruts[2]).rubbish(0);
this.edgestruts.pop();
this.edgestruts.pop();
this.edgestruts.pop();
}

setCenter(){
let c1 = 0;

if(this.facestruts.length != 4 && (c1 < 2)){this.createFaceStruts();c1++;}

c1 = lr(this.facestruts[0]).InfInt3(this.facestruts[1]);
if(dr(c1) instanceof RefDot){
this.center = c1;return;}else{}
c1 = lr(this.facestruts[0]).InfInt3(this.facestruts[2]);
if(dr(c1) instanceof RefDot){this.center = c1;return;}else{}
c1 = lr(this.facestruts[0]).InfInt3(this.facestruts[3]);
if(dr(c1) instanceof RefDot){this.center = c1;return;}else{}
this.findAverageCenter();
this.averagecenter.print();

}

createLandSkyEdges(){
let sp1 = [];
sp1[0] = this.points[0];sp1[1] = this.points[1];
sp1[2] = this.points[2];sp1[3] = this.points[3];

// set 4th point as highest point
// assume (due to screen) that y is the 3rd sky dimensio
if( dr(sp1[0]).y > dr(sp1[3]).y){
let t1 = sp1[3]; sp1[3] = sp1[0]; sp1[0] = t1;
}
if( dr(sp1[1]).y > dr(sp1[3]).y){
let t1 = sp1[3]; sp1[3] = sp1[1]; sp1[1] = t1;
}
if( dr(sp1[2]).y > dr(sp1[3]).y){
let t1 = sp1[3]; sp1[3] = sp1[2]; sp1[2] = t1;
}

this.skyedges[0] = new RefLine(sp1[0], sp1[3]);
this.skyedges[1] = new RefLine(sp1[1], sp1[3]);
this.skyedges[2] = new RefLine(sp1[2], sp1[3]);
if(tr(this.landface) == -1){
this.landface = new RefTriangle(sp1[0], sp1[1], sp1[2]);
}

}

findAverageCenter(){
if(this.skyedges.length != 3){this.createLandSkyEdges();}
// A - B - C
// C - A - B
// B - C - A
this.averagecenter = new RefDot(0,0,0);
var Line1 = this.skyedges[0];
var Line2 = this.skyedges[1];
var Line3 = this.skyedges[2];
var counter = 0;;
var vert1 = 0; var vert2 = 0; var vert3 = 0;
for(let id1 = 0; id1 < this.skyedges[0].distance; id1++){
vert1 = Line1.crawlDistanceFromStart(id1);
vert2 = Line2.crawlDistanceFromStart(id1);
vert3 = Line3.crawlDistanceFromStart(id1);
//printoneline( one triangle = ${vert1} and ${vert2} and ${vert3});
var dytriangle = new RefTriangle(vert1, vert2, vert3);
dytriangle.makePlanarGraphOfTriangle();
dytriangle.rubbishplane();
this.averagecenter.addDot(dytriangle.averagecenter);
counter++;
dytriangle.rubbish(2);

}

this.averagecenter.singlefactormultiply(1/counter);
// printoutt("---------- EXITING THE VOLUMIZER --------------");
this.averagecenter.print();
}

}

class RefTimeViewerFrame {

constructor(canasID = "mainCnvs1", TTRatio = 1000) {
    this.cnv = document.getElementById(canasID);
        this.ctx = this.cnv.getContext("2d");
    this.cwidth = this.cnv.width;
    this.cheight = this.cnv.height;
    this.origin = new RefDot((this.cwidth/2), (this.cheight/2), 0);
	let x1 = new RefDot(0,0,0);
	this.observer = x1.regind;

this.timeratio  = TTRatio;
this.present = 0;
this.maxTime; 
//ideal concept holds ideal objects that have 'interface' of x.draw and x.center
//And an appropriate multi-object has
//a time-ordered list of objects (i.e: timeslice.) 
//this.concept = new MultiLineObject();

}
	
TickingHand(){

clearTimeout(this.presdela);
this.present++;
if(this.present >= this.maxTime){
this.present = 0;
}
// process the 3D for this.present's tick

//set up delay for next tick;
this.presdela = setTimeout(this.TickingHand, this.TTRatio);

}		

createnewcanvas(xmax = 300,ymax = 300){
//each refViewerFrame has its own canvas
var ne1 = document.createNewElement("CANVAS");
ne1.width = xmax;
ne1.height = ymax;
return ne1;
}

insertnewcanvas(pa = document.body, newcan = 0){
//because each ViewerFrame has its own canvas, in the case of displaying 5D each viewerframe works in 4D, so the greater_world organizing the 5D needs to hold the viewerframes and initialize them.
//after the creation and insertion , an array can hold the canvases, as this.cnv, then each '5d' realm, can have its own cnv to swap in, if this 'canvasframe' is supposed to house the whole page.

if(newcan){pa.appendChild(newcan);}

}

whitebackground(){
this.ctx.beginPath();
this.ctx.fillStyle="#ffffff";
this.ctx.fillRect(0,0,this.cwidth, this.cheight);
}
wipenfresh () {
this.ctx.clearRect(0,0,this.cwidth,this.cheight);
// this.tempdrawhorizonguides();
// this.remakeaxis(3,this.origin);
}

clr () {
        this.wipenfresh();
    }

findoppositerightanglewithadjacentandoppositesangle (adj, opang){
let adan = degtorad(90);
adan -= opang;
let sineA = Math.sin(adan);
let FrA = adj/sineA;
return (FrA * Math.sin(opang));
}

drawatom (px, py, amu, kala = "#00FF00"){
let nx = Number(this.origin.x) + Number(px);
let ny = Number(this.origin.y) - Number(py);

nx = Number.parseFloat(nx).toFixed(1);
ny = Number.parseFloat(ny).toFixed(1);
printoutt(DRAW ATOM ${nx} and ${ny});
let paintgrd = this.ctx.createRadialGradient(nx, ny ,3,nx ,ny, (amu*3));
paintgrd.addColorStop(0, kala);
paintgrd.addColorStop(1, kala);
this.ctx.fillStyle = paintgrd;
this.ctx.beginPath();
this.ctx.arc(nx, ny, amu ,0, 2 * Math.PI);
this.ctx.stroke();
this.ctx.fill();

}

drawaline (addedrefline) {
// dx1 = addedrefline.start.x; dy1 = addedrefline.start.y;
this.ctx.beginPath();
this.ctx.strokeStyle = addedrefline.colour;
this.ctx.lineWidth = addedrefline.siz;
let uab = parseInt(this.origin.x) + parseInt(dr(addedrefline.start).x);
let nab = parseInt(this.origin.x) + parseInt(dr(addedrefline.end).x);
let uba = parseInt(this.origin.y) - parseInt(dr(addedrefline.start).y);
let nba = parseInt(this.origin.y) - parseInt(dr(addedrefline.end).y);

	this.ctx.moveTo(uab,uba );
    this.ctx.lineTo(nab,nba);
    this.ctx.stroke();   
}

depthdraw (Rhine){
//This is the portal for a line to reach the screen.
let RivStr = dr(dr(Rhine.start).copyOfDot());
let RivEnd = dr(dr(Rhine.end).copyOfDot());
//copyOfDot an attempt to fix a mysterious incrementally hyperbolic addition
RivStr.setX(RivStr.x + dr(this.observer).x);
RivEnd.setX(RivEnd.x + dr(this.observer).x);
RivStr.setY(RivStr.y + dr(this.observer).y);
RivEnd.setY(RivEnd.y + dr(this.observer).y);
RivStr.setZ(RivStr.z + dr(this.observer).z);
RivEnd.setZ(RivEnd.z + dr(this.observer).z);

//7 and with opposite = x or y, then angle a is above
// 0.4636476090008054=radians angle
let realmspanse = this.findoppositerightanglewithadjacentandoppositesangle(RivStr.z , 0.463647609000805);
realmspanse *= 2;
//8then ((opposite * 2) + viewerspan) = x at z ,
realmspanse += this.cwidth;
//9 then the ratio(z) = viewerspan / x(z)
let realmspanseratio = this.cwidth/realmspanse;
//11 once ratio(z) = canvas/spanse(z), then for point (x,y,z), the x=0->x
//12 so ratio(z) * x = f(x)<x
let sx1 = RivStr.x * realmspanseratio;
realmspanse = realmspanse - this.cwidth + this.cheight;
realmspanseratio = this.cheight/realmspanse;
let sy1 = RivStr.y * realmspanseratio;
// end point
realmspanse = this.findoppositerightanglewithadjacentandoppositesangle(RivEnd.z , 0.463647609000805);
realmspanse *= 2;
//8then ((opposite * 2) + viewerspan) = x at z ,
realmspanse += this.cwidth;
realmspanseratio = this.cwidth/realmspanse;
let ex1 = RivEnd.x * realmspanseratio;
realmspanse = realmspanse - this.cwidth + this.cheight;
realmspanseratio = this.cheight/realmspanse;
let ey1 = RivEnd.y * realmspanseratio;
var newlin = new RefLine(new RefDot(sx1,sy1,0), new RefDot(ex1,ey1,0));

newlin.colour = Rhine.colour;
newlin.siz = Rhine.siz;
//printoutt("
depthdraw " + newlin.describeline());

if( RivStr.atomic != -1){
this.drawatom(sx1,
sy1,
RivStr.atomic * realmspanseratio,
RivStr.colour);
}
if(RivEnd.atomic != -1){
this.drawatom(ex1,ey1,RivEnd.atomic * realmspanseratio, RivEnd.colour);
}
this.drawaline(newlin);
newlin.rubbish(1);
RivStr.rubbish();
RivEnd.rubbish();
}

drawRegLine(RLineIndx){
var t1;
if(RLineIndx instanceof RefLine){
t1 = RLineIndx;
}else{
t1 = lr(RLineIndx);
}
if(t1 instanceof RefLine){
this.depthdraw(t1);
}

}

}//
var globalviewerframe = new RefTimeViewerFrame();

var a1 = new RefTimeViewerFrame();
a1.whitebackground();
var d1 = new RefDot(200,140,150,100);
var d2 = new RefDot(100,200,100,100);
var d3 = new RefDot(01,20,10,100);
var d4 = new RefDot(100,02,-50,100);

d1.colour = "#c0ec0e";
d2.colour = "#234589";
d3.colour = "#b4638a";
d1.atomic = 10;
d2.atomic = 10;
d3.atomic = 10;
var L1 = new RefLine(d3,d1);
var T1 = new RefTetrahedron(L1);

printoutt("center of tetrahedron is " + JSON.stringify(dr(T1.center)));
printoutt("averagecenter of tetrahedron is " + JSON.stringify((T1.averagecenter)));

a1.depthdraw(lr(T1.lines[0]));
a1.depthdraw(lr(T1.lines[1]));
a1.depthdraw(lr(T1.lines[2]));
a1.depthdraw(lr(T1.lines[3]));
a1.depthdraw(lr(T1.lines[4]));
a1.depthdraw(lr(T1.lines[5]));

function tickertape () {
a1.whitebackground();
a1.depthdraw(L1);
}

</script> <script> var ProcStack = []; function startermotor() { ProcStack.push(window.setInterval(tickertape, 1000)); } function endmotor () { clearInterval(ProcStack.pop()); } </script> `