canvas-based-core 1.0.4 → 1.0.5

package/canvas/model/canvasArc2D.js

@@ -1,16 +1,33 @@
-import { Arc2D } from "../../model/arc2D.js";
+import { Arc2D } from "../../geometry/module.js";
 import { StyleType } from "../styleType.js";
 
 export class CanvasArc2D extends Arc2D {
 
     //props
-    ctx;
     styleType;
     style;
 
-    constructor(ctx, x, y, radius = 0, startAngle = 0, endAngle = 0, style = "#000000", styleType = StyleType.FILL, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, radius, startAngle, endAngle, xVelocity, yVelocity);
-        this.ctx = ctx;
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        radius = 0, 
+        startAngle = 0, 
+        endAngle = 0, 
+        style = "#000000", 
+        styleType = StyleType.FILL, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            radius, 
+            startAngle, 
+            endAngle, 
+            xVelocity, 
+            yVelocity
+        );
         this.styleType = styleType;
         this.style = style;
     }
@@ -30,29 +47,29 @@ export class CanvasArc2D extends Arc2D {
         return this;
     }
 
-    draw(){
-        this.#resolveDraw();
+    draw(ctx){
+        this.#resolveDraw(ctx);
     }
 
-    #resolveDraw(){
+    #resolveDraw(ctx){
         switch(this.styleType){
             case StyleType.FILL:
-                this.ctx.fillStyle = this.style;
-                this.ctx.beginPath();
-                this.ctx.arc(this.x, this.y, this.radius, this.startAngle, this.endAngle);
-                this.ctx.fill();
+                ctx.fillStyle = style;
+                ctx.beginPath();
+                ctx.arc(this.originX, this.originY, this.radius, this.startAngle, this.endAngle);
+                ctx.fill();
                 break;
             case StyleType.STROKE:
-                this.ctx.strokeStyle = this.style;
-                this.ctx.beginPath();
-                this.ctx.arc(this.x, this.y, this.radius, this.startAngle, this.endAngle);
-                this.ctx.stroke();
+                ctx.strokeStyle = this.style;
+                ctx.beginPath();
+                ctx.arc(this.originX, this.originY, this.radius, this.startAngle, this.endAngle);
+                ctx.stroke();
         }
     }
 
     clear(){
-        const x = (this.x - this.radius);
-        const y = (this.y - this.radius);
+        const x = (this.originX - this.radius);
+        const y = (this.originY - this.radius);
         const diameter = (this.radius * 2);
         this.ctx.clearRect(x, y, diameter, diameter);
     }

package/canvas/model/canvasCircle2D.js

@@ -1,25 +1,35 @@
-import { Circle2D } from "../../model/circle2D.js";
+import { Circle2D } from "../../geometry/module.js";
 import { StyleType } from "../styleType.js";
 
 export class CanvasCircle2D extends Circle2D {
 
     //props
-    ctx;
     styleType;
     style;
 
-    constructor(ctx, x, y, radius = 0, style = "#000000", styleType = StyleType.FILL, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, radius, xVelocity, yVelocity);
+    //ctor
+    constructor(
+        ctx, 
+        originX, 
+        originY, 
+        radius = 0, 
+        style = "#000000", 
+        styleType = StyleType.FILL, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            radius, 
+            xVelocity, 
+            yVelocity
+        );
         this.ctx = ctx;
         this.styleType = styleType;
         this.style = style;
     }
 
-    setCTX(val){
-        this.ctx = val;
-        return this;
-    }
-
     setStyleType(val){
         this.styleType = val;
         return this;
@@ -39,20 +49,20 @@ export class CanvasCircle2D extends Circle2D {
             case StyleType.FILL:
                 this.ctx.fillStyle = this.style;
                 this.ctx.beginPath();
-                this.ctx.arc(this.x, this.y, this.radius, this.startAngle, this.endAngle);
+                this.ctx.arc(this.originX, this.originY, this.radius, this.startAngle, this.endAngle);
                 this.ctx.fill();
                 break;
             case StyleType.STROKE:
                 this.ctx.strokeStyle = this.style;
                 this.ctx.beginPath();
-                this.ctx.arc(this.x, this.y, this.radius, this.startAngle, this.endAngle);
+                this.ctx.arc(this.originX, this.originY, this.radius, this.startAngle, this.endAngle);
                 this.ctx.stroke();
         }
     }
 
     clear(){
-        const x = (this.x - this.radius);
-        const y = (this.y - this.radius);
+        const x = (this.originX - this.radius);
+        const y = (this.originY - this.radius);
         const diameter = (this.radius * 2);
         this.ctx.clearRect(x, y, diameter, diameter);
     }

package/canvas/model/canvasLine2D.js

@@ -1,13 +1,24 @@
-import { Line2D } from "../../model/line2D.js";
+import { Line2D } from "../../geometry/module.js";
 
 export class CanvasLine2D extends Line2D {
 
-    ctx;
+    //props
     style;
 
-    constructor(ctx, originX, originY, targetX, targetY, style = "#000000"){
-        super(originX, originY, targetX, targetY);
-        this.ctx = ctx;
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        targetX, 
+        targetY, 
+        style = "#000000"
+    ){
+        super(
+            originX, 
+            originY, 
+            targetX, 
+            targetY
+        );
         this.style = style;
     }
 

package/canvas/model/canvasRect2D.js

@@ -1,23 +1,39 @@
-import { Rect2D } from "../../model/rect2D.js";
+import { Rect2D } from "../../geometry/module.js";
 import { StyleType } from "../styleType.js";
 
 export class CanvasRect2D extends Rect2D {
 
     //props
-    ctx;
     styleType;
     style;
+    rotation = 0.00;
+    rotationSpeed = 0.00;
 
-    constructor(ctx, x, y, height, width, style = "#000000", styleType = StyleType.FILL, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, height, width, xVelocity, yVelocity);
-        this.ctx = ctx;
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        height, 
+        width, 
+        style = "#000000", 
+        styleType = StyleType.FILL, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00, 
+        rotation = 0.00, 
+        rotationSpeed = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            height, 
+            width, 
+            xVelocity, 
+            yVelocity
+        );
         this.styleType = styleType;
         this.style = style;
-    }
-
-    setCTX(val){
-        this.ctx = val;
-        return this;
+        this.rotation = rotation;
+        this.rotationSpeed = rotationSpeed;
     }
 
     setStyleType(val){
@@ -30,35 +46,65 @@ export class CanvasRect2D extends Rect2D {
         return this;
     }
 
-    draw(){
-        this.#resolveDraw();
+    setRotation(val){
+        this.rotation = val;
+        return this;
+    }
+
+    setRotationSpeed(val){
+        this.rotationSpeed = val;
+        return this;
+    }
+
+    draw(ctx){
+        ctx.save();
+        ctx.translate(this.originX, this.originY);
+        this.#resolveDraw(ctx, this.originX, this.originY);
+        ctx.resetTransform();
+        ctx.restore();
+    }
+
+    rotate(ctx){
+        this.#resetRotation();
+        this.rotation += this.rotationSpeed;
+        ctx.save();
+        ctx.translate(this.originX, this.originY);
+        ctx.rotate(this.rotation);
+        this.#resolveDraw(ctx, (-this.originX / this.originX), (-this.originY / this.originY));
+        ctx.resetTransform();
+        ctx.restore();
+    }
+
+    spin(ctx){
+        this.#resetRotation();
+        this.rotation += this.rotationSpeed;
+        ctx.save();
+        ctx.translate(this.originX, this.originY);
+        ctx.rotate(this.rotation);
+        this.#resolveDraw(ctx, (-this.width / 2), (-this.height / 2));
+        ctx.resetTransform();
+        ctx.restore();
+    }
+
+    clear(ctx){
+        ctx.clearRect(this.originX, this.originY, this.width, this.height);
     }
 
-    #resolveDraw(){
+    #resolveDraw(ctx, originX, originY){
         switch(this.styleType){
             case StyleType.FILL:
-                this.ctx.fillStyle = this.style;
-                this.ctx.fillRect(this.x, this.y, this.width, this.height);
+                ctx.fillStyle = this.style;
+                ctx.fillRect(originX, originY, this.width, this.height);
                 break;
             case StyleType.STROKE:
-                this.ctx.strokeStyle = this.style;
-                this.ctx.strokeRect(this.x, this.y, this.width, this.height);
+                ctx.strokeStyle = this.style;
+                ctx.strokeRect(originX, originY, this.width, this.height);
         }
     }
-
-    clear(){
-        this.ctx.clearRect(this.x, this.y, this.width, this.height);
-    }
-
-    rotate(degree){
-        this.ctx.save();
-        this.degree = (this.degree + degree) % 360;
-        const rad = this.degree * (Math.PI / 180);
-        this.ctx.translate(this.x, this.y);
-        this.ctx.rotate(rad);
-        this.ctx.fillRect((-this.width / 2), (-this.height / 2), this.width, this.height);
-        this.ctx.resetTransform();
-        this.ctx.restore();
+    
+    #resetRotation(){
+        if(this.rotation > (2 * Math.PI)){
+            this.rotation = 0;
+        }
     }
-
 }

package/canvas/module.js

@@ -0,0 +1,17 @@
+import { CanvasCollisionDetection } from "./collisionDetection/canvasCollisionDetection.js";
+import { CanvasCollisionDetection2D } from "./collisionDetection/canvasCollisionDetection2D.js";
+import { CanvasArc2D } from "./model/canvasArc2D.js";
+import { CanvasCircle2D } from "./model/canvasCircle2D.js";
+import { CanvasLine2D } from "./model/canvasLine2D.js";
+import { CanvasRect2D } from "./model/canvasRect2D.js";
+import { StyleType } from "./styleType.js";
+
+export {
+    CanvasCollisionDetection,
+    CanvasCollisionDetection2D,
+    StyleType,
+    CanvasArc2D,
+    CanvasCircle2D,
+    CanvasLine2D,
+    CanvasRect2D
+}

package/{collisionDetection → geometry/2D/collisionDetection}/collisionDetection2D.js

@@ -1,5 +1,5 @@
 import { CollisionDetection } from "./collisionDetection.js";
-import { Point2D } from "../geometry/point2D.js";
+import { Point2D } from "../point2D.js";
 
 export class CollisionDetection2D extends CollisionDetection {
 
@@ -30,6 +30,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static getRightCollisionDetected(source, target){
@@ -39,6 +42,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static getHorizontalCollisionDetected(source, target){
@@ -48,6 +54,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static topCollisionDetected(source, target){
@@ -73,6 +82,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static getBottomCollisionDetected(source, target){
@@ -82,6 +94,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static getVerticalCollisionDetected(source, target){
@@ -91,6 +106,9 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
     static collisionDetected(source, target){
@@ -104,15 +122,18 @@ export class CollisionDetection2D extends CollisionDetection {
                 target: new Point2D(target.x, target.y)
             }
         }
+        else{
+            return null;
+        }
     }
 
-    static #isWithinXRange(source, target){
-        return (((source.x + source.width) >= target.x) && (source.x <= target.x)) || 
-               ((source.x <= (target.x + target.width)) && (source.x >= target.x)); 
+    static #isWithinXRange(source, target) {
+        return ((source.x + source.width) >= target.x) || 
+               (source.x <= (target.x + target.width));
     }
 
-    static #isWithinYRange(source, target){
-        return (((source.y + source.height) >= target.y) && (source.y <= target.y)) || 
-               ((source.y <= (target.y + target.height)) && (source.y >= target.y));
+    static #isWithinYRange(source, target) {
+        return ((source.y + source.height) >= target.y) || 
+               (source.y <= (target.y + target.height));
     }
 }

package/geometry/2D/model/arc2D.js

@@ -0,0 +1,45 @@
+import { Object2D } from "./object2D.js";
+
+export class Arc2D extends Object2D {
+
+    //props
+    radius = 0;
+    startAngle = 0;
+    endAngle = 0;
+
+    constructor(
+        originX, 
+        originY, 
+        radius = 0, 
+        startAngle = 0, 
+        endAngle = 0, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            xVelocity, 
+            yVelocity
+        );
+        this.radius = radius;
+        this.startAngle = startAngle;
+        this.endAngle = endAngle;
+    }
+
+    setRadius(val){
+        this.radius = val;
+        return this;
+    }
+
+    setStartAngle(val){
+        this.startAngle = val;
+        return this;
+    }
+
+    setEndAngle(val){
+        this.endAngle = val;
+        return this;
+    }
+
+}

package/geometry/2D/model/circle2D.js

@@ -0,0 +1,23 @@
+import { Arc2D } from "./arc2D.js";
+
+export class Circle2D extends Arc2D {
+
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        radius = 0, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            radius, 0, 
+            (Math.PI * 2), 
+            xVelocity, 
+            yVelocity
+        );
+    }
+
+}

package/{model → geometry/2D/model}/line2D.js

@@ -1,13 +1,19 @@
-export class Line2D {
+import { Object2D } from "./object2D.js";
 
-    originX;
-    originX;
-    targetX;
-    targetY;
+export class Line2D extends Object2D {
 
-    constructor(originX, originY, targetX, targetY){
-        this.originX = originX;
-        this.originY = originY;
+    //props
+    targetX = 0;
+    targetY = 0;
+
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        targetX, 
+        targetY
+    ) {
+        super(originX, originY);
         this.targetX = targetX;
         this.targetY = targetY;
     }

package/geometry/2D/model/object2D.js

@@ -0,0 +1,51 @@
+export class Object2D {
+
+    //props
+    originX = 0;
+    originY = 0;
+    xVelocity = 0.00;
+    yVelocity = 0.00;
+
+    //ctor
+    constructor(
+        originX = 0, 
+        originY = 0, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        this.originX = originX;
+        this.originY = originY;
+        this.xVelocity = xVelocity;
+        this.yVelocity = yVelocity;
+    }
+
+    //prop methods
+    setOriginX(val){
+        this.originX = val;
+        return this;
+    }
+
+    setOriginY(val){
+        this.originY = val;
+        return this;
+    }
+
+    setXVelocity(val){
+        this.xVelocity = val;
+        return this;
+    }
+
+    setYVelocity(val){
+        this.yVelocity = val;
+        return this;
+    }
+    //
+
+    moveOriginXByXVelocity(){
+        this.originX += this.xVelocity;
+    }
+
+    moveOriginYByYVelocity(){
+        this.originY += this.yVelocity;
+    }
+}

package/geometry/2D/model/rect2D.js

@@ -0,0 +1,83 @@
+import { Object2D } from "./object2D.js";
+import { Point2D } from "../point2D.js";
+import { Line2D } from "./line2D.js";
+
+export class Rect2D extends Object2D {
+    
+    //props
+    height = 0;
+    width = 0;
+
+    //ctor
+    constructor(
+        originX, 
+        originY, 
+        height, 
+        width, 
+        xVelocity = 0.00, 
+        yVelocity = 0.00
+    ) {
+        super(
+            originX, 
+            originY, 
+            xVelocity, 
+            yVelocity
+        );
+        this.height = height;
+        this.width = width;
+    }
+
+    setHeight(val){
+        this.height = val;
+        return this;
+    }
+
+    setWidth(val){
+        this.width = val;
+        return this;
+    }
+
+    getTopLeftCoord(){
+        const x = this.originX;
+        const y = this.originY;
+        return new Point2D(x, y);
+    }
+
+    getTopRightCoord(){
+        const x = (this.originX + this.width);
+        const y = this.originY;
+        return new Point2D(x, y);
+    }
+
+    getTop(){
+        return new Line2D(this.originX, this.originY, this.originX + this.width, this.originY);
+    }
+
+    getBottomRightCoord(){
+        const x = (this.originX + this.width);
+        const y = (this.originY + this.height);
+        return new Point2D(x, y);
+    }
+
+    getBottomLeftCoord(){
+        const x = this.originX;
+        const y = (this.originY + this.height);
+        return new Point2D(x, y);
+    }
+
+    getBottom(){
+        return new Line2D(this.originX, this.originY + this.height, this.originX + this.width, this.originY + this.height);
+    }
+
+    getCenterCoord(){
+        const x = ((this.originX + this.width) / 2);
+        const y = ((this.originY + this.height) / 2);
+        return new Point2D(x, y);
+    }
+
+    getCoordinates(){
+        //clockwise from origin x, y ie topleft
+        //[topleft, topright, bottomright, bottomleft, center]
+        return [this.getTopLeftCoord(), this.getTopRightCoord(), this.getBottomRightCoord(), this.getBottomLeftCoord(), this.getCenterCoord()];
+    }
+}

package/{model/objectBase3D.js → geometry/3D/model/object3D.js}

@@ -1,13 +1,12 @@
-import { ObjectBase2D } from "./ObjectBase2D.js";
+import { Object2D } from "../../2D/model/object2D.js";
 
-export class ObjectBase3D extends ObjectBase2D {
+export class Object3D extends Object2D {
 
     //props
-    //type int
     z;
-    //type float
-    zVelocity;
+    zVelocity = 0.00;
 
+    //ctor
     constructor(x, y, z, xVelocity = 0.00, yVelocity = 0.00, zVelocity = 0.00) {
         super(x, y, xVelocity, yVelocity);
         this.z = z;

package/geometry/{point3D.js → 3D/point3D.js}

@@ -1,4 +1,4 @@
-import { Point2D } from "./point2D.js";
+import { Point2D } from "../2D/point2D.js";
 
 export class Point3D extends Point2D {
 

package/geometry/module.js

@@ -0,0 +1,23 @@
+import { CollisionDetection } from "./2D/collisionDetection/collisionDetection.js";
+import { CollisionDetection2D } from "./2D/collisionDetection/collisionDetection2D.js";
+import { Point2D } from "./2D/point2D.js";
+import { Point3D } from "./3D/point3D.js";
+import { Object2D } from "./2D/model/object2D.js";
+import { Object3D } from "./3D/model/object3D.js";
+import { Arc2D } from "./2D/model/arc2D.js";
+import { Circle2D } from "./2D/model/circle2D.js";
+import { Line2D } from "./2D/model/line2D.js";
+import { Rect2D } from "./2D/model/rect2D.js";
+
+export {
+    CollisionDetection,
+    CollisionDetection2D,
+    Point2D,
+    Point3D,
+    Object2D,
+    Object3D,
+    Arc2D,
+    Circle2D,
+    Line2D,
+    Rect2D
+}

package/module.js

@@ -2,26 +2,21 @@
 import { 
     KeyCode,
     KeyboardControlMapBase
-} from "./control/control-module.js";
-
-import { 
-    Point2D, 
-    Point3D 
-} from "./geometry/geometry-module.js";
+} from "./controller/module.js";
 
 import { 
     CollisionDetection, 
-    CollisionDetection2D 
-} from "./collisionDetection/collisionDetection-module.js";
-
-import { 
-    ObjectBase2D,
-    ObjectBase3D,
+    CollisionDetection2D,
+    Point2D, 
+    Point3D,
+    Object2D,
+    Object3D,
     Arc2D,
     Circle2D,
     Line2D,
     Rect2D 
-} from "./model/model-module.js";
+} from "./geometry/module.js";
+
 
 import { 
     StyleType,
@@ -31,7 +26,7 @@ import {
     CanvasCircle2D,
     CanvasLine2D,
     CanvasRect2D 
-} from "./canvas/canvas-module.js";
+} from "./canvas/module.js";
 
 
 export {
@@ -42,8 +37,8 @@ export {
     CollisionDetection,
     CollisionDetection2D,
     StyleType,
-    ObjectBase2D,
-    ObjectBase3D,
+    Object2D,
+    Object3D,
     Arc2D,
     Circle2D,
     Line2D,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canvas-based-core",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "canvas-based-core",
   "homepage": "https://github.com/pr1v4te4cc0unt/canvas-based-core#readme",
   "bugs": {

package/test.js

@@ -1,27 +1,37 @@
-import * as Core from "./moduleExport.js";
+import * as Core from "./module.js";
 
 var canvas = document.querySelector("canvas");
 var ctx = canvas.getContext("2d");
 
-var circle = new Core.CanvasCircle2D(ctx, 50, 50, 10);
-console.log(circle);
+// var circle = new Core.CanvasCircle2D(50, 50, 10);
+// console.log(circle);
 
-setInterval(() => circle.draw(), 1000);
-setInterval(() => circle.clear(), 2000);
+// setInterval(() => circle.draw(ctx), 1000);
+// setInterval(() => circle.clear(), 2000);
 
-var rectOne = new Core.CanvasRect2D(ctx, 100, 50, 10, 10).setStyle("black");
-rectOne.draw();
+var rectOne = new Core.CanvasRect2D(100, 50, 30, 30);
+rectOne.setRotationSpeed(0.05).draw(ctx);
 // console.log(rectOne);
 
-var rectTwo = new Core.CanvasRect2D(ctx, 120, 50, 10, 10).setStyle("green");
-rectTwo.draw();
+var rectTwo = new Core.CanvasRect2D(130, 50, 10, 10).setStyle("green");
+rectTwo.draw(ctx);
 // console.log(rectTwo);
 
-var rectThree = new Core.CanvasRect2D(ctx, 140, 50, 10, 10).setStyle("blue");
-rectThree.draw();
-
-rectOne.draw();
-rectTwo.draw();
-rectThree.draw();
+var rectThree = new Core.CanvasRect2D(150, 50, 10, 10).setStyle("blue");
+rectThree.setRotationSpeed(-0.05).draw(ctx);
 // console.log(rectOne);
 
+function animate(){
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    
+    rectOne.spin(ctx);
+
+    rectTwo.draw(ctx);
+
+    rectThree.draw(ctx);
+
+    requestAnimationFrame(animate);
+}
+
+animate();
+

package/canvas/canvas-module.js

@@ -1,25 +0,0 @@
-import { 
-    CanvasCollisionDetection, 
-    CanvasCollisionDetection2D 
-} from "./collisionDetection/canvas-collisionDetection-module.js";
-
-import {
-    CanvasArc2D,
-    CanvasCircle2D,
-    CanvasLine2D,
-    CanvasRect2D
-} from "./model/canvas-model-module.js";
-
-import { 
-    StyleType 
-} from "./styleType.js";
-
-export {
-    CanvasCollisionDetection,
-    CanvasCollisionDetection2D,
-    StyleType,
-    CanvasArc2D,
-    CanvasCircle2D,
-    CanvasLine2D,
-    CanvasRect2D
-}

package/canvas/collisionDetection/canvas-collisionDetection-module.js

@@ -1,7 +0,0 @@
-import { CanvasCollisionDetection } from "./canvasCollisionDetection.js";
-import { CanvasCollisionDetection2D } from "./canvasCollisionDetection2D.js";
-
-export {
-    CanvasCollisionDetection,
-    CanvasCollisionDetection2D
-}

package/canvas/model/canvas-model-module.js

@@ -1,11 +0,0 @@
-import { CanvasArc2D } from "./canvasArc2D.js";
-import { CanvasCircle2D } from "./canvasCircle2D.js";
-import { CanvasLine2D } from "./canvasLine2D.js";
-import { CanvasRect2D } from "./canvasRect2D.js";
-
-export {
-    CanvasArc2D,
-    CanvasCircle2D,
-    CanvasLine2D,
-    CanvasRect2D
-}

package/collisionDetection/collisionDetection-module.js

@@ -1,7 +0,0 @@
-import { CollisionDetection } from "./collisionDetection.js";
-import { CollisionDetection2D } from "./collisionDetection2D.js";
-
-export {
-    CollisionDetection,
-    CollisionDetection2D
-}

package/geometry/geometry-module.js

@@ -1,7 +0,0 @@
-import { Point2D } from "./point2D.js";
-import { Point3D } from "./point3D.js";
-
-export {
-    Point2D,
-    Point3D
-}

package/model/arc2D.js

@@ -1,33 +0,0 @@
-import { ObjectBase2D } from "./ObjectBase2D.js";
-
-export class Arc2D extends ObjectBase2D {
-
-    //props
-    //type int
-    radius = 0;
-    startAngle = 0;
-    endAngle = 0;
-
-    constructor(x, y, radius = 0, startAngle = 0, endAngle = 0, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, xVelocity, yVelocity);
-        this.radius = radius;
-        this.startAngle = startAngle;
-        this.endAngle = endAngle;
-    }
-
-    setRadius(val){
-        this.radius = val;
-        return this;
-    }
-
-    setStartAngle(val){
-        this.startAngle = val;
-        return this;
-    }
-
-    setEndAngle(val){
-        this.endAngle = val;
-        return this;
-    }
-
-}

package/model/circle2D.js

@@ -1,9 +0,0 @@
-import { Arc2D } from "./arc2D.js";
-
-export class Circle2D extends Arc2D {
-
-    constructor(x, y, radius = 0, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, radius, 0, (Math.PI * 2), xVelocity, yVelocity);
-    }
-
-}

package/model/model-module.js

@@ -1,15 +0,0 @@
-import { Arc2D } from "./arc2D.js";
-import { Circle2D } from "./circle2D.js";
-import { Line2D } from "./line2D.js";
-import { Rect2D } from "./rect2D.js";
-import { ObjectBase2D } from "./ObjectBase2D.js";
-import { ObjectBase3D } from "./ObjectBase3D.js";
-
-export {
-    ObjectBase2D,
-    ObjectBase3D,
-    Arc2D,
-    Circle2D,
-    Line2D,
-    Rect2D
-}    

package/model/objectBase2D.js

@@ -1,48 +0,0 @@
-export class ObjectBase2D {
-
-    //props
-    //type int
-    x;
-    y;
-    //type float
-    xVelocity;
-    yVelocity;
-
-    //ctor
-    constructor(x, y, xVelocity = 0.00, yVelocity = 0.00) {
-        this.x = x;
-        this.y = y;
-        this.xVelocity = xVelocity;
-        this.yVelocity = yVelocity;
-    }
-
-    //prop methods
-    setX(val){
-        this.x = val;
-        return this;
-    }
-
-    setY(val){
-        this.y = val;
-        return this;
-    }
-
-    setXVelocity(val){
-        this.xVelocity = val;
-        return this;
-    }
-
-    setYVelocity(val){
-        this.yVelocity = val;
-        return this;
-    }
-    //
-
-    moveXByXVelocity(){
-        this.x += this.xVelocity;
-    }
-
-    moveYByYVelocity(){
-        this.y += this.yVelocity;
-    }
-}

package/model/rect2D.js

@@ -1,63 +0,0 @@
-import { ObjectBase2D } from "./ObjectBase2D.js";
-import { Point2D } from "../geometry/point2D.js";
-
-export class Rect2D extends ObjectBase2D {
-
-    //props
-    //type int
-    height;
-    width;
-
-    constructor(x, y, height, width, xVelocity = 0.00, yVelocity = 0.00) {
-        super(x, y, xVelocity, yVelocity);
-        this.height = height;
-        this.width = width;
-    }
-
-    setHeight(val){
-        this.height = val;
-        return this;
-    }
-
-    setWidth(val){
-        this.width = val;
-        return this;
-    }
-
-    getTopLeftCoord(){
-        const x = this.x;
-        const y = this.y;
-        return new Point2D(x, y);
-    }
-
-    getTopRightCoord(){
-        const x = (this.x + this.width);
-        const y = this.y;
-        return new Point2D(x, y);
-    }
-
-    getBottomRightCoord(){
-        const x = (this.x + this.width);
-        const y = (this.y + this.height);
-        return new Point2D(x, y);
-    }
-
-    getBottomLeftCoord(){
-        const x = this.x;
-        const y = (this.y + this.height);
-        return new Point2D(x, y);
-    }
-
-    getCenterCoord(){
-        const x = ((this.x + this.width) / 2);
-        const y = ((this.y + this.height) / 2);
-        return new Point2D(x, y);
-    }
-
-    getCoordinates(){
-        //clockwise from origin x, y ie topleft
-        //[topleft, topright, bottomright, bottomleft, center]
-        return [this.getTopLeftCoord(), this.getTopRightCoord(), this.getBottomRightCoord(), this.getBottomLeftCoord(), this.getCenterCoord()];
-    }
-
-}