Tilemap collision working but needs speeding up

node_modules/grunt-contrib-watch/docs/watch-examples.md

@@ -0,0 +1,68 @@
+# Examples
+
+```js
+// Simple config to run jshint any time a file is added, changed or deleted
+grunt.initConfig({
+  watch: {
+    files: '**/*',
+    tasks: ['jshint']
+  }
+});
+```
+
+```js
+// Advanced config. Run specific tasks when specific files are added, changed or deleted.
+grunt.initConfig({
+  watch: {
+    gruntfile: {
+      files: 'Gruntfile.js',
+      tasks: ['jshint:gruntfile'],
+      options: {
+        nocase: true
+      }
+    },
+    src: {
+      files: ['lib/*.js', 'css/**/*.scss', '!lib/dontwatch.js'],
+      tasks: ['default']
+    },
+    test: {
+      files: '<%= jshint.test.src %>',
+      tasks: ['jshint:test', 'qunit']
+    }
+  }
+});
+```
+
+```js
+// Example using watch events
+grunt.initConfig({
+  watch: {
+    scripts: {
+      files: ['lib/*.js']
+    }
+  }
+});
+
+// Listen for events when files are modified
+grunt.event.on('watch', function(action, filepath) {
+  grunt.log.writeln(filepath + ' has ' + action);
+});
+```
+
+# FAQs
+
+## How do I fix the error `EMFILE: Too many opened files.`?
+This is because of your system's max opened file limit. For OSX the default is very low (256). Temporarily increase your limit with `ulimit -n 10480`, the number being the new max limit.
+
+## Can I use this with Grunt v0.3?
+Yes. Although `grunt-contrib-watch` is a replacement watch task for Grunt v0.4, version `grunt-contrib-watch@0.1.x` is compatible with Grunt v0.3. `grunt-contrib-watch >= 0.2.x` is **only* compatible and recommended to use with Grunt v0.4.
+
+## Why is the watch devouring all my memory?
+Likely because of an enthusiastic pattern trying to watch thousands of files. Such as `'**/*.js'` but forgetting to exclude the `node_modules` folder with `'!node_modules/**/*.js'`. Try grouping your files within a subfolder or be more explicit with your file matching pattern.
+
+## Why spawn as child processes as a default?
+The goal of this watch task is as files are changed, run tasks as if they were triggered by the user themself. Each time a user runs `grunt` a process is spawned and tasks are ran in succession. In an effort to keep the experience consistent and continualy produce expected results, this watch task spawns tasks as child processes by default.
+
+Sandboxing task runs also allows this watch task to run more stable over long periods of time. As well as more efficiently with more complex tasks and file structures.
+
+Spawning does cause a performance hit (usually 500ms for most environments). It also cripples tasks that rely on the watch task to share the context with each subsequent run (i.e., reload tasks). If you would like a faster watch task or need to share the context please set the `nospawn` option to `true`. Just be aware that with this option enabled, the watch task is more prone to failure.

node_modules/grunt-contrib-watch/docs/watch-options.md

@@ -0,0 +1,76 @@
+# Settings
+
+There are a number of options available. Please review the [minimatch options here](https://github.com/isaacs/minimatch#options). As well as some additional options as follows:
+
+## files
+Type: `String|Array`
+
+This defines what file patterns this task will watch. Can be a string or an array of files and/or minimatch patterns.
+
+## tasks
+Type: `String|Array`
+
+This defines which tasks to run when a watched file event occurs.
+
+## options.nospawn
+Type: `Boolean`
+Default: false
+
+This instructs the watch task to not spawn task runs in a child process. Setting this option also speeds up the reaction time of the watch (usually 500ms faster for most) and allows subsequent task runs to share the same context (i.e., using a reload task). Not spawning task runs can make the watch more prone to failing so please use as needed.
+
+Example:
+```js
+watch: {
+  scripts: {
+    files: ['**/*.js'],
+    tasks: ['livereload'],
+    options: {
+      nospawn: true
+    }
+  }
+}
+```
+
+## options.interrupt
+Type: `Boolean`
+Default: false
+
+As files are modified this watch task will spawn tasks in child processes. The default behavior will only spawn a new child process per target when the previous process has finished. Set the `interrupt` option to true to terminate the previous process and spawn a new one upon later changes.
+
+Example:
+```js
+watch: {
+  scripts: {
+    files: '**/*.js',
+    tasks: ['jshint'],
+    options: {
+      interrupt: true
+    }
+  }
+}
+```
+
+## options.debounceDelay
+Type: `Integer`
+Default: 500
+
+How long to wait before emitting events in succession for the same filepath and status. For example if your `Gruntfile.js` file was `changed`, a `changed` event will only fire again after the given milliseconds.
+
+Example:
+```js
+watch: {
+  scripts: {
+    files: '**/*.js',
+    tasks: ['jshint'],
+    options: {
+      debounceDelay: 250
+    }
+  }
+}
+```
+
+## options.interval
+Type: `Integer`
+Default: 100
+
+The `interval` is passed to `fs.watchFile`. Since `interval` is only used by `fs.watchFile` and this watcher also uses `fs.watch`; it is recommended to ignore this option. *Default is 100ms*.