initial commit

Author: TendTo

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1 @@
+*.ts

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Tend
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,34 @@
+# A* pathfinding algorithm simulator
+Astar algorithm applied to a pathfinding scenario, with the ability to see the algorithm in action, step by step.
+ 
+## :red_circle: Online version
+A live version is available [here](https://drendog.github.io/Logic-Circuit-Simulator/).
+![](demo.gif)
+ 
+## :books: Documentation
+[Documentation](https://google.com)
+
+## 🤝 Contributing
+
+Contributions, issues and feature requests are welcome.<br>
+I'd especially appreciate every feedback aimed at improving the presentation and any bug report
+
+## :wrench: Made with
+[p5.js library](https://github.com/processing/p5.js)<br>
+[BOOSTRAP](https://getbootstrap.com/)
+
+## :book: Reference sources
+
+[Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm)<br>
+[Heuristics](http://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html)
+
+## :thought_balloon: Inspired by
+[Logic Circuit Simulator](https://github.com/drendog/Logic-Circuit-Simulator)
+
+## 👤 Author
+
+**[Tend](https://github.com/TendTo)**
+
+## :balance_scale: License
+
+[MIT](https://choosealicense.com/licenses/mit/)

doc/DOC.md

@@ -0,0 +1,226 @@
+## Documentation
+
+### Constants
+Vertical and Horizontal cost: 10
+Diagonal cost: 14
+
+### Heuristics
+ To find the h value, there are 4 possible heuristics contemplated:
+- **Manhattan distance:** estimate the distance considering only horizontal-vertical movements. Ignores obstacles
+- **Diagonal distance:** estimate the distance considering all the 8 possible directions. Ignores obstacles
+- **Euclid distance:** estimate the distance as the crow flies. Ignores obstacles
+- **Dijkstra (h = 0):** always set h = 0. It behaves exactly like Dijkstra's  algorithm
+
+### main.js
+```javascript
+/**
+* Called at the start
+*/
+function  setup()
+
+/**
+* Called each frame
+*/
+function  draw()
+
+/**
+* Set up the buttons variables and set the value for each button in settings
+*/
+function  setupButtons()
+
+/**
+* Initialize the squares matrix so that everyghing is walkable
+*/
+function  initializeMatrix()
+
+/**
+* Udate the matrix with the new width and height but trying to keep the elements that don't need deleting
+*/
+function  updateMatrix()
+/**
+* Draw the square matrix on the canvas, according to the state of each square
+*/
+function  drawMatrix()
+
+/**
+* Draw both end and start positions
+*/
+function  drawStartEnd()
+
+/**
+* Make the selected palette follow the mouse
+*/
+function  drawCurrentMouse()
+
+/**
+* If the position is valid, apply the correct palette on the square
+*/
+function  mousePressed()
+
+/**
+* If the mouse is locked, keep drawing the current palette
+*/
+function  mouseDragged()
+  
+/**
+* Unlock the mouse
+*/
+function  mouseReleased()
+
+/**
+* Check if the given vecor is inside the matrix borders
+* @param  {p5.Vector}  v - Vetor to check
+* @returns  {boolean} Whether or not the vector is valid
+*/
+
+function  validVector(v)
+
+/**
+* Set the start position and checks for any conflicts
+* @param  {number}  x - x coordinate of the start position
+* @param  {number}  y - y coordinate of the start position
+*/
+function  setStart(x, y)
+
+/**
+* Set the end position and checks for any conflicts
+* @param  {number}  x - x coordinate of the end position
+* @param  {number}  y - y coordinate of the end position
+*/
+function  setEnd(x, y)
+  
+/**
+* If the start or end position are on this point, remove them
+* @param  {number}  x - x coordinate of the point
+* @param  {number}  y - y coordinate of the point
+*/
+function  removeStartEnd(x, y)
+
+/**
+* Start the astar algorithm animation
+*/
+function  startAlgotithm()
+
+/**
+* Clears the board
+*/
+function  clearBoard()
+
+/**
+* Set the palette with the given index {walkable, unwalkable, start, end, special_ground}
+* @param  {string}  id - id of the wanted palette
+*/
+function  setPalette(id)
+
+/**
+* Apply the changes in the settings
+*/
+function  apply()
+
+/**
+* Cancels every change in the settings
+*/
+function  cancel()
+
+/**
+  Set the currentStatus value based of the chosen status
+* @param  {string}  newStatus - status to use when changing the editor mode value
+*/
+function  setStatus(newStatus)
+```
+### astar.js
+```javascript
+/**
+* Class that handles the A* algorithm
+*/
+class  Astar
+
+/**
+* Create an istance of Astar
+*/
+constructor()
+  
+/**
+* Start the algorithm animation
+*/
+startAlgorithm()
+
+/**
+* Clear the point matrix and the openPoints array
+*/
+clearAll()
+
+/**
+* Inizialize the starting point
+*/
+initializeAlgorithm()
+
+/**
+* Follows the Astar algorithm step by step. Called each frame
+*/
+stepSolution()  
+
+/**
+* Check all the neighbours of the point and, if they are valid points, calculate their f value
+* @param  {number}  x - x coordinate of the point
+* @param  {number}  y - y coordinate of the point
+*/
+checkNeighbours(x, y)
+  
+/**
+* Calculate the new F value for the point, if the g provided is less than the current g
+* @param  {number}  x - x coordinate of the point
+* @param  {number}  y - y coordinate of the point
+* @param  {number}  g - new g value calculated for the point
+*/
+calculateF(x, y, g, px, py) 
+
+/**
+* Calculate the heuristic distance from the indicated point to the end point
+* @param  {number}  x - x coordinate of the point
+* @param  {number}  y - y coordinate of the point
+* @returns  {number} The value h
+*/
+calculateH(x, y)
+
+/**
+* Retrace the path discovered by the Astar algorithm and color it
+*/
+retracePath()   
+
+/**
+* Retrace the all the path tried by the Astar algorithm and color it
+*/
+retraceFailPath()
+
+/**
+* Generate a string containing all the point's info
+* @param  {number}  x - x coordinate of the point
+* @param  {number}  y - y coordinate of the point
+* @returns  {string} - Point's info: h, g and f values
+*/
+getPointInfo(x, y)  
+
+/**
+* Draw some text on the chosen square
+* @param  {number}  x - x coordinate of the square
+* @param  {number}  y - y coordinate of the square
+* @param  {boolean}  override - whether or not the intern of the square should be recolored
+*/
+drawText(x, y, override)
+  
+
+/**
+* Draw a stroke around the chosen square
+* @param  {number}  x - x coordinate of the square
+* @param  {number}  y - y coordinate of the square
+* @param  {p5.color}  color - color of the stroke
+*/
+drawFocus(x, y, color)  
+
+/**
+* Push the point into the openPoints array, if it is not present yet
+* @param  {any}  point - point to push in the array
+*/
+pushToOpenNodes(point)
+```