+48 -33

.github/CONTRIBUTING.md

Reviewed

··· 1 1 # How to Contribute 2 2 3 3 #### Code of Conduct 4 4 + 4 5 This project is released with a [Contributor Code of Conduct](CODE_OF_CONDUCT.md). By participating in this project, you agree to abide by its terms. 5 6 6 7 #### Questions 8 8 + 7 9 Have questions? Ask them in our [forum]! 8 10 9 11 #### Table of Contents 12 12 + 10 13 - [Reporting Bugs](#reporting-bugs) 11 14 - [Suggesting Improvements](#suggesting-improvements) 12 15 - [Submitting Changes](#submitting-changes) ··· 19 22 - [Tests](#tests) 20 23 - [Documentation](#documentation) 21 24 - [Issue Labels](#issue-labels) 22 22 - 23 25 24 26 ## Reporting Bugs 27 27 + 25 28 Before reporting a bug, please perform the following troubleshooting steps: 26 29 27 27 - 1. Check to see if the problem has already been reported 28 28 - - Take a look through the list of [known bugs][search-label-bug] to see if someone has already created an issue that describes the problem you’re experiencing. If an issue already exists, consider adding any additional context you have about the problem in a comment on that issue. 29 29 - 2. Try the latest stable version of Excalibur 30 30 - - If you’re not using the latest [release][releases], the problem may already be fixed. Please upgrade to the latest stable version and see if you still experience the problem. 31 31 - - Alternatively, if you’re using a new unstable release, try rolling back to the latest stable release. 32 32 - 3. Try using older versions of Excalibur 33 33 - - If you’re already using the latest release, try out the previous few versions. This will help us determine where the problem first appeared. 34 34 - 4. Try different browsers 35 35 - - The problem you’re seeing may only appear in certain browsers or mobile devices. If you can, please try several different browsers/platforms to see if the issue persists. 30 30 + 1. Check to see if the problem has already been reported 31 31 + - Take a look through the list of [known bugs][search-label-bug] to see if someone has already created an issue that describes the problem you’re experiencing. If an issue already exists, consider adding any additional context you have about the problem in a comment on that issue. 32 32 + 2. Try the latest stable version of Excalibur 33 33 + - If you’re not using the latest [release][releases], the problem may already be fixed. Please upgrade to the latest stable version and see if you still experience the problem. 34 34 + - Alternatively, if you’re using a new unstable release, try rolling back to the latest stable release. 35 35 + 3. Try using older versions of Excalibur 36 36 + - If you’re already using the latest release, try out the previous few versions. This will help us determine where the problem first appeared. 37 37 + 4. Try different browsers 38 38 + - The problem you’re seeing may only appear in certain browsers or mobile devices. If you can, please try several different browsers/platforms to see if the issue persists. 36 39 37 40 ## Suggesting Improvements 41 41 + 38 42 Please do a quick search through our [backlog][issues] to see if your improvement has already been suggested. If so, feel free to provide additional comments or thoughts on the existing issue. 39 43 40 44 ## Submitting Changes 41 45 42 46 ### Getting Started 47 47 + 43 48 Below is the general workflow for submitting changes: 44 49 45 45 - 1. [Discuss an issue you want to contribute to](#discussing-a-contribution) 46 46 - 2. Create a fork of Excalibur 47 47 - 3. Commit to your fork with your initial changes 48 48 - 4. [Submit a work-in-progress pull request to discuss with the maintainers](#creating-a-pull-request) 49 49 - 5. Make changes to your pull request as needed 50 50 - 6. Once your changes are merged, celebrate! 50 50 + 1. [Discuss an issue you want to contribute to](#discussing-a-contribution) 51 51 + 2. Create a fork of Excalibur 52 52 + 3. Commit to your fork with your initial changes 53 53 + 4. [Submit a work-in-progress pull request to discuss with the maintainers](#creating-a-pull-request) 54 54 + 5. Make changes to your pull request as needed 55 55 + 6. Once your changes are merged, celebrate! 51 56 52 57 If you’re not sure where to start, take a look at the "good first issue" or "help wanted" [issue labels](#issue-labels). 58 58 + 53 59 - Issues tagged with "good first issue" are designed as an introduction to contributing to open source and the Excalibur project as a whole. 54 60 - Issues tagged with "help wanted" tend to be more involved than good first issues. 55 61 56 62 #### Discussing a Contribution 63 63 + 57 64 It's helpful to let us know that you'd like to contribute for an issue, to prevent duplicate work. Ask us any questions you have about the issue, so that we can clarify the work you'll need to do. We're here to help! 58 65 59 66 #### Creating a Pull Request 67 67 + 60 68 - Please ensure that there is an issue created for what you're working on. This helps us track the work being done! 61 69 - Open a pull request as soon as you feel you have the beginning of something workable, or if you have design ideas to discuss. Getting feedback from us early will help you with your work! We will flag the pull request as Work-In-Progress while we work with you on your contribution. 62 70 - Do all of your work in a new git branch. Only include code in the branch for the single issue you are working on. ··· 73 81 - Format your pull request title as: [#issue_number] Your commit message (where issue_number is the issue you're closing), and fill out the pull request template that automatically populates the editor window. Please format your pull request title according to our [commit message styleguide](#commit-messages). 74 82 75 83 #### Deprecating Code 84 84 + 76 85 If you've replaced a piece of Excalibur's API, please mark it as `@obsolete` and provide the new preferred method of performing the same task. Don't forget to include which release it will be removed in! Deprecations are typically performed during the next release, so if your changes are made for the 0.1.0 release, they will be removed in 0.2.0. 77 86 78 87 If the code you are deprecating is called anywhere else in Excalibur, or in any documentation, please update those places to use the new code you've written. 79 88 80 80 - example: 89 89 + example: 90 90 + 81 91 ```ts 82 92 /** @obsolete use [[SomeClass]].someNewFunction instead **/ 83 83 - @obsolete({message: 'ex.SomeClass.someFunction is deprecated, and will be removed in 0.2.0', 93 93 + @obsolete({message: 'ex.SomeClass.someFunction is deprecated, and will be removed in 0.2.0', 84 94 alternateMethod: 'SomeClass.someNewFunction'}) 85 95 public someFunction() {...} 86 96 ``` ··· 94 104 An example of exporting all public members from a new `MyClass.ts` that contains a `MyClass` ES6 class: 95 105 96 106 ```ts 97 97 - export * from './MyClass' 107 107 + export * from './MyClass'; 98 108 // ex.MyClass will be exposed 99 109 ``` 100 110 ··· 103 113 ```ts 104 114 // ex.Feature namespace 105 115 import * as feature from './MyClass'; 106 106 - export { feature as Feature } 116 116 + export { feature as Feature }; 107 117 // ex.Feature.MyClass will be exposed 108 118 ``` 109 119 110 120 ## Styleguides 111 121 112 122 #### Code 123 123 + 113 124 A number of our code formatting rules are enforced via linting. When you build Excalibur on your computer, the linter will make sure that certain aspects of your code are formatted properly. Additionally: 125 125 + 114 126 - Use 3 spaces for indenting 115 127 - All methods must explicitly specify their access modifier (public, private, etc.) 116 128 - Use the CamelCase naming convention, with a lowercase first letter for variables. 117 129 118 130 #### Commit Messages 131 131 + 119 132 Follow the guidelines below to help maintain a readable and informative git history: 133 133 + 120 134 - Use present tense verbs (“Fix bug where…” instead of “Fixed bug where…”) 121 135 - Use imperative mood (“Add new feature” instead of “Adds new feature”) 122 136 - Capitalize the first letter of the first line ··· 128 142 - If your change is small, you may only need to write a single line commit message, e.x. “Fix typo in documentation” 129 143 130 144 Here are the guidelines applied in a sample commit message, along with some additional helpful hints: 145 145 + 131 146 ``` 132 147 Summarize what the commit does in <=50 characters 133 148 ··· 152 167 Resolves: #100 153 168 See also: #200, #300 154 169 ``` 170 170 + 155 171 #### Tests 172 172 + 156 173 All features, changes, and bug fixes must be tested by specifications (unit tests). Write tests to cover any potential scenarios your code introduces. 157 174 158 175 Here’s an example: 176 176 + 159 177 ```javascript 160 178 describe('a monkey', () => { 161 161 - it('climbs trees', () => { 162 162 - // put your spec here to show that monkeys climb trees 163 163 - }); 164 164 - describe('when the monkey is hungry', () => { 165 165 - it('eats a banana', () => { 166 166 - // put your spec here to show that this is true 167 167 - }); 179 179 + it('climbs trees', () => { 180 180 + // put your spec here to show that monkeys climb trees 181 181 + }); 182 182 + describe('when the monkey is hungry', () => { 183 183 + it('eats a banana', () => { 184 184 + // put your spec here to show that this is true 168 185 }); 186 186 + }); 169 187 }); 170 188 ``` 171 189 172 190 #### Documentation 173 173 - - Add JSDoc comments to all public and protected methods 191 191 + 192 192 + - Add JSDoc comments to all public and protected methods 174 193 - Link to other classes using the TypeDoc double bracket notation. 175 194 176 195 ## Issue Labels 196 196 + 177 197 - [good first issue][search-label-good first issue]: issues that are good starting points for new contributors to open source 178 198 - [help wanted][search-label-help wanted]: issues that are more in-depth and may require a certain platform or skillset to implement 179 199 - [bug][search-label-bug]: a problem or an unexpected behavior 180 200 181 201 If you'd like to contribute, these labels are good places to start. Our remaining labels are documented on the [Labels page](https://github.com/excaliburjs/Excalibur/labels). 182 202 183 183 - 184 184 - 185 185 - 186 203 [forum]: https://groups.google.com/forum/#!forum/excaliburjs 187 204 [releases]: https://github.com/excaliburjs/Excalibur/releases 188 205 [issues]: https://github.com/excaliburjs/Excalibur/issues 189 189 - 190 206 [keep-a-changelog]: http://keepachangelog.com/en/0.3.0/ 191 191 - 192 207 [search-label-good first issue]: https://github.com/excaliburjs/Excalibur/labels/good%20first%20issue 193 208 [search-label-help wanted]: https://github.com/excaliburjs/Excalibur/labels/help%20wanted 194 209 [search-label-bug]: https://github.com/excaliburjs/Excalibur/labels/bug

+62 -2

CHANGELOG.md

Reviewed

··· 11 11 12 12 ### Added 13 13 14 14 - <!--- Added features here ---> 14 14 + - New `ex.Collider` type which is the container for all collision related behavior and state. Actor is now extracted from collision. 15 15 + - Added interface `Clonable<T>` to indicate if an object contains a clone method 16 16 + - Added interface `Eventable<T>` to indicated if an object can emit and receive events 17 17 + - `ex.Vector.scale` now also works with vector input 18 18 + - `ex.BoundingBox.fromDimension(width: number, height: number)` can generate a bounding box from a width and height 19 19 + - `ex.BoundingBox.translate(pos: Vector)` will create a new bounding box shifted by `pos` 20 20 + - `ex.BoundingBox.scale(scale: Vector)` will create a new bounding box scaled by `scale` 21 21 + - Added `isActor()` and `isCollider()` type guards 22 22 + - Added `ex.CollisionShape.draw` collision shapes can now be drawn, actor's will use these shapes if no other drawing is specified 15 23 16 24 ### Changed 17 25 18 26 - Changed event handlers in excalibur to expect non-null event objects, before `hander: (event?: GameEvent) => void` implied that event could be null. This change addresses ([#1147](https://github.com/excaliburjs/Excalibur/issues/1147)) making strict null/function checks compatible with new typescript. 27 27 + - Changed collision system to remove actor coupling, in addition `ex.Collider` is a new type that encapsulates all collision behavior. Use `ex.Actor.body.collider` to interact with collisions in Excalibur ([#1119](https://github.com/excaliburjs/Excalibur/issues/1119)) 28 28 + 29 29 + - Add new `ex.Collider` type that is the housing for all collision related code 30 30 + - The source of truth for `ex.CollisionType` is now on collider, with a convenience getter on actor 31 31 + - The collision system now operates on `ex.Collider`'s not `ex.Actor`'s 32 32 + - `ex.CollisionType` has been moved to a separate file outside of `Actor` 33 33 + - CollisionType is switched to a string enum, style guide also updated 34 34 + - `ex.CollisionPair` now operates on a pair of `ex.Colliders`'s instead of `ex.Actors`'s 35 35 + - `ex.CollisionContact` now operates on a pair of `ex.Collider`'s instead of `ex.Actors`'s 36 36 + - `ex.Body` has been modified to house all the physical position/transform information 37 37 + - Integration has been moved from actor to `Body` as a physical concern 38 38 + - `useBoxCollision` has been renamed to `useBoxCollider` 39 39 + - `useCircleCollision` has been renamed to `useCircleCollider` 40 40 + - `usePolygonCollision` has been renamed to `usePolygonCollider` 41 41 + - `useEdgeCollision` has been renamed to `useEdgeCollider` 42 42 + - Renamed `ex.CollisionArea` to `ex.CollisionShape` 43 43 + - `ex.CircleArea` has been renamed to `ex.Circle` 44 44 + - `ex.PolygonArea` has been renamed to `ex.ConvexPolygon` 45 45 + - `ex.EdgeArea` has been renamed to `ex.Edge` 46 46 + - Renamed `getWidth()` & `setWidth()` to property `width` 47 47 + - Actor and BoundingBox are affected 48 48 + - Renamed `getHeight()` & `setHeight()` to property `height` 49 49 + - Actor and BoundingBox are affected 50 50 + - Renamed `getCenter()` to the property `center` 51 51 + - Actor, BoundingBox, and Cell are affected 52 52 + - Renamed `getBounds()` to the property `bounds` 53 53 + - Actor, Collider, and Shapes are affected 54 54 + - Renamed `getRelativeBounds()` to the property `localBounds` 55 55 + - Actor, Collider, and Shapes are affected 56 56 + - Renamed `moi()` to the property `inertia` standing for moment of inertia 57 57 + - Renamed `restition` to the property `bounciness` 58 58 + - Moved `collisionType` to `Actor.body.collider.type` 59 59 + - Moved `Actor.integrate` to `Actor.body.integrate` 19 60 20 61 ### Deprecated 21 62 22 22 - <!--- Deprecations here ---> 63 63 + - Removed `NaiveCollisionBroadphase` as it was no longer used 64 64 + - Renamed methods and properties will be available until `v0.24.0` 65 65 + - Deprecated collision attributes on actor, use `Actor.body.collider` 66 66 + 67 67 + - `Actor.x` & `Actor.y` will be removed in `v0.24.0` use `Actor.pos.x` & `Actor.pos.y` 68 68 + - `Actor.collisionArea` will be removed in `v0.24.0` use `Actor.body.collider.shape` 69 69 + - `Actor.getLeft()`, `Actor.getRight()`, `Actor.getTop()`, and `Actor.getBottom` are deprecated 70 70 + - Use `Actor.body.collider.bounds.(left|right|top|bottom)` 71 71 + - `Actor.getGeometry()` and `Actor.getRelativeGeometry()` are removed, use `Collider` 72 72 + - Collision related properties on Actor moved to `Collider`, use`Actor.body.collider` 73 73 + - `Actor.torque` 74 74 + - `Actor.mass` 75 75 + - `Actor.moi` 76 76 + - `Actor.friction` 77 77 + - `Actor.restition` 78 78 + - Collision related methods on Actor moved to `Collider`, use`Actor.body.collider` or `Actor.body.collider.bounds` 79 79 + - `Actor.getSideFromIntersect(intersect)` -> `BoundingBox.sideFromIntersection` 80 80 + - `Actor.collidesWithSide(actor)` -> `Actor.body.collider.bounds.intersectWithSide` 81 81 + - `Actor.collides(actor)` -> `Actor.body.collider.bounds.intersect` 23 82 24 83 ### Fixed 25 84 ··· 27 86 - Fixed polyfill application by exporting a `polyfill()` function that can be called. ([#1132](https://github.com/excaliburjs/Excalibur/issues/1132)) 28 87 29 88 <!--- Bug fixes here ---> 89 89 + 30 90 - Fixed Color.lighten() ([#1084]) 31 91 32 92 <!--------------------------------- DO NOT EDIT BELOW THIS LINE --------------------------------->

+36

STYLEGUIDE.md

Reviewed

··· 98 98 ### DON’T 99 99 100 100 - Use an “I” prefix, do not use things like `IDrawable` should be `Drawable` 101 101 + 102 102 + ## Enums 103 103 + 104 104 + #### DO 105 105 + 106 106 + - Use `number`ed or `string` enums, preferring `string` enums for more robust type support, robust refactorings, and debuggability at run-time 107 107 + 108 108 + ```typescript 109 109 + export enum CollisionType { 110 110 + /** 111 111 + * Actors with the `PreventCollision` setting do not participate in any 112 112 + * collisions and do not raise collision events. 113 113 + */ 114 114 + PreventCollision = 'PreventCollision', 115 115 + /** 116 116 + * Actors with the `Passive` setting only raise collision events, but are not 117 117 + * influenced or moved by other actors and do not influence or move other actors. 118 118 + */ 119 119 + Passive = 'Passive', 120 120 + /** 121 121 + * Actors with the `Active` setting raise collision events and participate 122 122 + * in collisions with other actors and will be push or moved by actors sharing 123 123 + * the `Active` or `Fixed` setting. 124 124 + */ 125 125 + Active = 'Active', 126 126 + /** 127 127 + * Actors with the `Fixed` setting raise collision events and participate in 128 128 + * collisions with other actors. Actors with the `Fixed` setting will not be 129 129 + * pushed or moved by other actors sharing the `Fixed`. Think of Fixed 130 130 + * actors as "immovable/onstoppable" objects. If two `Fixed` actors meet they will 131 131 + * not be pushed or moved by each other, they will not interact except to throw 132 132 + * collision events. 133 133 + */ 134 134 + Fixed = 'Fixed' 135 135 + } 136 136 + ```

+59 -59

package-lock.json

Reviewed

··· 713 713 }, 714 714 "async": { 715 715 "version": "1.5.2", 716 716 - "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", 716 716 + "resolved": "http://registry.npmjs.org/async/-/async-1.5.2.tgz", 717 717 "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=", 718 718 "dev": true 719 719 }, ··· 782 782 "dependencies": { 783 783 "jsesc": { 784 784 "version": "1.3.0", 785 785 - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", 785 785 + "resolved": "http://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", 786 786 "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=", 787 787 "dev": true 788 788 }, ··· 1105 1105 }, 1106 1106 "browserify-aes": { 1107 1107 "version": "1.2.0", 1108 1108 - "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", 1108 1108 + "resolved": "http://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", 1109 1109 "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", 1110 1110 "dev": true, 1111 1111 "requires": { ··· 1150 1150 }, 1151 1151 "browserify-rsa": { 1152 1152 "version": "4.0.1", 1153 1153 - "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", 1153 1153 + "resolved": "http://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", 1154 1154 "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", 1155 1155 "dev": true, 1156 1156 "requires": { ··· 1236 1236 }, 1237 1237 "cacache": { 1238 1238 "version": "10.0.4", 1239 1239 - "resolved": "https://registry.npmjs.org/cacache/-/cacache-10.0.4.tgz", 1239 1239 + "resolved": "http://registry.npmjs.org/cacache/-/cacache-10.0.4.tgz", 1240 1240 "integrity": "sha512-Dph0MzuH+rTQzGPNT9fAnrPmMmjKfST6trxJeK7NQuHRaVw24VzPRWTmg9MpcwOVQZO0E1FBICUlFeNaKPIfHA==", 1241 1241 "dev": true, 1242 1242 "requires": { ··· 1316 1316 }, 1317 1317 "camelcase-keys": { 1318 1318 "version": "2.1.0", 1319 1319 - "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz", 1319 1319 + "resolved": "http://registry.npmjs.org/camelcase-keys/-/camelcase-keys-2.1.0.tgz", 1320 1320 "integrity": "sha1-MIvur/3ygRkFHvodkyITyRuPkuc=", 1321 1321 "dev": true, 1322 1322 "requires": { ··· 2047 2047 }, 2048 2048 "colors": { 2049 2049 "version": "1.1.2", 2050 2050 - "resolved": "https://registry.npmjs.org/colors/-/colors-1.1.2.tgz", 2050 2050 + "resolved": "http://registry.npmjs.org/colors/-/colors-1.1.2.tgz", 2051 2051 "integrity": "sha1-FopHAXVran9RoSzgyXv6KMCE7WM=", 2052 2052 "dev": true 2053 2053 }, ··· 2321 2321 }, 2322 2322 "create-hash": { 2323 2323 "version": "1.2.0", 2324 2324 - "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", 2324 2324 + "resolved": "http://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", 2325 2325 "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", 2326 2326 "dev": true, 2327 2327 "requires": { ··· 2334 2334 }, 2335 2335 "create-hmac": { 2336 2336 "version": "1.1.7", 2337 2337 - "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", 2337 2337 + "resolved": "http://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", 2338 2338 "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", 2339 2339 "dev": true, 2340 2340 "requires": { ··· 2702 2702 }, 2703 2703 "diffie-hellman": { 2704 2704 "version": "5.0.3", 2705 2705 - "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", 2705 2705 + "resolved": "http://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", 2706 2706 "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", 2707 2707 "dev": true, 2708 2708 "requires": { ··· 2858 2858 }, 2859 2859 "engine.io-client": { 2860 2860 "version": "3.2.1", 2861 2861 - "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-3.2.1.tgz", 2861 2861 + "resolved": "http://registry.npmjs.org/engine.io-client/-/engine.io-client-3.2.1.tgz", 2862 2862 "integrity": "sha512-y5AbkytWeM4jQr7m/koQLc5AxpRKC1hEVUb/s1FUAWEJq5AzJJ4NLvzuKPuxtDi5Mq755WuDvZ6Iv2rXj4PTzw==", 2863 2863 "dev": true, 2864 2864 "requires": { ··· 2969 2969 }, 2970 2970 "es6-promise": { 2971 2971 "version": "0.1.2", 2972 2972 - "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-0.1.2.tgz", 2972 2972 + "resolved": "http://registry.npmjs.org/es6-promise/-/es6-promise-0.1.2.tgz", 2973 2973 "integrity": "sha1-8RLCn+paCZhTn8tqL9IUQ9KPBfc=", 2974 2974 "dev": true 2975 2975 }, ··· 3086 3086 }, 3087 3087 "eventemitter2": { 3088 3088 "version": "0.4.14", 3089 3089 - "resolved": "https://registry.npmjs.org/eventemitter2/-/eventemitter2-0.4.14.tgz", 3089 3089 + "resolved": "http://registry.npmjs.org/eventemitter2/-/eventemitter2-0.4.14.tgz", 3090 3090 "integrity": "sha1-j2G3XN4BKy6esoTUVFWDtWQ7Yas=", 3091 3091 "dev": true 3092 3092 }, ··· 3881 3881 }, 3882 3882 "fs-access": { 3883 3883 "version": "1.0.1", 3884 3884 - "resolved": "https://registry.npmjs.org/fs-access/-/fs-access-1.0.1.tgz", 3884 3884 + "resolved": "http://registry.npmjs.org/fs-access/-/fs-access-1.0.1.tgz", 3885 3885 "integrity": "sha1-1qh/JiJxzv6+wwxVNAf7mV2od3o=", 3886 3886 "dev": true, 3887 3887 "requires": { ··· 3942 3942 }, 3943 3943 "get-stream": { 3944 3944 "version": "3.0.0", 3945 3945 - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", 3945 3945 + "resolved": "http://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", 3946 3946 "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=", 3947 3947 "dev": true 3948 3948 }, ··· 4095 4095 "dependencies": { 4096 4096 "semver": { 4097 4097 "version": "4.3.6", 4098 4098 - "resolved": "https://registry.npmjs.org/semver/-/semver-4.3.6.tgz", 4098 4098 + "resolved": "http://registry.npmjs.org/semver/-/semver-4.3.6.tgz", 4099 4099 "integrity": "sha1-MAvG4OhjdPe6YQaLWx7NV/xlMto=", 4100 4100 "dev": true 4101 4101 } ··· 4113 4113 "dependencies": { 4114 4114 "semver": { 4115 4115 "version": "4.3.6", 4116 4116 - "resolved": "https://registry.npmjs.org/semver/-/semver-4.3.6.tgz", 4116 4116 + "resolved": "http://registry.npmjs.org/semver/-/semver-4.3.6.tgz", 4117 4117 "integrity": "sha1-MAvG4OhjdPe6YQaLWx7NV/xlMto=", 4118 4118 "dev": true 4119 4119 } ··· 4143 4143 }, 4144 4144 "grunt-contrib-connect": { 4145 4145 "version": "1.0.2", 4146 4146 - "resolved": "https://registry.npmjs.org/grunt-contrib-connect/-/grunt-contrib-connect-1.0.2.tgz", 4146 4146 + "resolved": "http://registry.npmjs.org/grunt-contrib-connect/-/grunt-contrib-connect-1.0.2.tgz", 4147 4147 "integrity": "sha1-XPkzuRpnOGBEJzwLJERgPNmIebo=", 4148 4148 "dev": true, 4149 4149 "requires": { ··· 4318 4318 "dependencies": { 4319 4319 "rimraf": { 4320 4320 "version": "2.2.6", 4321 4321 - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.2.6.tgz", 4321 4321 + "resolved": "http://registry.npmjs.org/rimraf/-/rimraf-2.2.6.tgz", 4322 4322 "integrity": "sha1-xZWXVpsU2VatKcrMQr3d9fDqT0w=", 4323 4323 "dev": true 4324 4324 } ··· 4580 4580 }, 4581 4581 "http-errors": { 4582 4582 "version": "1.6.3", 4583 4583 - "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", 4583 4583 + "resolved": "http://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", 4584 4584 "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", 4585 4585 "dev": true, 4586 4586 "requires": { ··· 4866 4866 }, 4867 4867 "is-accessor-descriptor": { 4868 4868 "version": "0.1.6", 4869 4869 - "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", 4869 4869 + "resolved": "http://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz", 4870 4870 "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=", 4871 4871 "dev": true, 4872 4872 "requires": { ··· 4896 4896 }, 4897 4897 "is-builtin-module": { 4898 4898 "version": "1.0.0", 4899 4899 - "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", 4899 4899 + "resolved": "http://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", 4900 4900 "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", 4901 4901 "dev": true, 4902 4902 "requires": { ··· 4914 4914 }, 4915 4915 "is-data-descriptor": { 4916 4916 "version": "0.1.4", 4917 4917 - "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", 4917 4917 + "resolved": "http://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz", 4918 4918 "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=", 4919 4919 "dev": true, 4920 4920 "requires": { ··· 5444 5444 }, 5445 5445 "jsesc": { 5446 5446 "version": "0.5.0", 5447 5447 - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", 5447 5447 + "resolved": "http://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", 5448 5448 "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=", 5449 5449 "dev": true 5450 5450 }, ··· 5480 5480 }, 5481 5481 "json5": { 5482 5482 "version": "0.5.1", 5483 5483 - "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", 5483 5483 + "resolved": "http://registry.npmjs.org/json5/-/json5-0.5.1.tgz", 5484 5484 "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", 5485 5485 "dev": true 5486 5486 }, ··· 5691 5691 }, 5692 5692 "load-json-file": { 5693 5693 "version": "1.1.0", 5694 5694 - "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", 5694 5694 + "resolved": "http://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", 5695 5695 "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", 5696 5696 "dev": true, 5697 5697 "requires": { ··· 5955 5955 }, 5956 5956 "media-typer": { 5957 5957 "version": "0.3.0", 5958 5958 - "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", 5958 5958 + "resolved": "http://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", 5959 5959 "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=", 5960 5960 "dev": true 5961 5961 }, ··· 5982 5982 }, 5983 5983 "meow": { 5984 5984 "version": "3.7.0", 5985 5985 - "resolved": "https://registry.npmjs.org/meow/-/meow-3.7.0.tgz", 5985 5985 + "resolved": "http://registry.npmjs.org/meow/-/meow-3.7.0.tgz", 5986 5986 "integrity": "sha1-cstmi0JSKCkKu/qFaJJYcwioAfs=", 5987 5987 "dev": true, 5988 5988 "requires": { ··· 6092 6092 }, 6093 6093 "minimist": { 6094 6094 "version": "1.2.0", 6095 6095 - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", 6095 6095 + "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", 6096 6096 "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", 6097 6097 "dev": true 6098 6098 }, ··· 6137 6137 }, 6138 6138 "mkdirp": { 6139 6139 "version": "0.5.1", 6140 6140 - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", 6140 6140 + "resolved": "http://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", 6141 6141 "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", 6142 6142 "dev": true, 6143 6143 "requires": { ··· 6146 6146 "dependencies": { 6147 6147 "minimist": { 6148 6148 "version": "0.0.8", 6149 6149 - "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", 6149 6149 + "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", 6150 6150 "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", 6151 6151 "dev": true 6152 6152 } ··· 6274 6274 }, 6275 6275 "ncp": { 6276 6276 "version": "0.5.1", 6277 6277 - "resolved": "https://registry.npmjs.org/ncp/-/ncp-0.5.1.tgz", 6277 6277 + "resolved": "http://registry.npmjs.org/ncp/-/ncp-0.5.1.tgz", 6278 6278 "integrity": "sha1-dDmFMW49tFkoG1hxaehFc1oFQ58=", 6279 6279 "dev": true 6280 6280 }, ··· 6335 6335 "dependencies": { 6336 6336 "buffer": { 6337 6337 "version": "4.9.1", 6338 6338 - "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", 6338 6338 + "resolved": "http://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", 6339 6339 "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", 6340 6340 "dev": true, 6341 6341 "requires": { ··· 6513 6513 }, 6514 6514 "opn": { 6515 6515 "version": "4.0.2", 6516 6516 - "resolved": "https://registry.npmjs.org/opn/-/opn-4.0.2.tgz", 6516 6516 + "resolved": "http://registry.npmjs.org/opn/-/opn-4.0.2.tgz", 6517 6517 "integrity": "sha1-erwi5kTf9jsKltWrfyeQwPAavJU=", 6518 6518 "dev": true, 6519 6519 "requires": { ··· 6533 6533 "dependencies": { 6534 6534 "minimist": { 6535 6535 "version": "0.0.10", 6536 6536 - "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz", 6536 6536 + "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.10.tgz", 6537 6537 "integrity": "sha1-3j+YVD2/lggr5IrRoMfNqDYwHc8=", 6538 6538 "dev": true 6539 6539 }, ··· 6627 6627 }, 6628 6628 "os-tmpdir": { 6629 6629 "version": "1.0.2", 6630 6630 - "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", 6630 6630 + "resolved": "http://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", 6631 6631 "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=", 6632 6632 "dev": true 6633 6633 }, ··· 6751 6751 }, 6752 6752 "path-browserify": { 6753 6753 "version": "0.0.0", 6754 6754 - "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", 6754 6754 + "resolved": "http://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", 6755 6755 "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=", 6756 6756 "dev": true 6757 6757 }, ··· 6772 6772 }, 6773 6773 "path-is-absolute": { 6774 6774 "version": "1.0.1", 6775 6775 - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", 6775 6775 + "resolved": "http://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", 6776 6776 "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" 6777 6777 }, 6778 6778 "path-key": { ··· 6825 6825 }, 6826 6826 "pify": { 6827 6827 "version": "2.3.0", 6828 6828 - "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", 6828 6828 + "resolved": "http://registry.npmjs.org/pify/-/pify-2.3.0.tgz", 6829 6829 "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", 6830 6830 "dev": true 6831 6831 }, ··· 7283 7283 }, 7284 7284 "readable-stream": { 7285 7285 "version": "2.3.6", 7286 7286 - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", 7286 7286 + "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", 7287 7287 "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", 7288 7288 "requires": { 7289 7289 "core-util-is": "~1.0.0", ··· 7359 7359 }, 7360 7360 "regjsgen": { 7361 7361 "version": "0.2.0", 7362 7362 - "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", 7362 7362 + "resolved": "http://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", 7363 7363 "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=", 7364 7364 "dev": true 7365 7365 }, 7366 7366 "regjsparser": { 7367 7367 "version": "0.1.5", 7368 7368 - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", 7368 7368 + "resolved": "http://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", 7369 7369 "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", 7370 7370 "dev": true, 7371 7371 "requires": { ··· 7482 7482 }, 7483 7483 "resolve": { 7484 7484 "version": "1.1.7", 7485 7485 - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", 7485 7485 + "resolved": "http://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", 7486 7486 "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=", 7487 7487 "dev": true 7488 7488 }, ··· 7563 7563 }, 7564 7564 "safe-regex": { 7565 7565 "version": "1.1.0", 7566 7566 - "resolved": "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", 7566 7566 + "resolved": "http://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz", 7567 7567 "integrity": "sha1-QKNmnzsHfR6UPURinhV91IAjvy4=", 7568 7568 "dev": true, 7569 7569 "requires": { ··· 7700 7700 }, 7701 7701 "sha.js": { 7702 7702 "version": "2.4.11", 7703 7703 - "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", 7703 7703 + "resolved": "http://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", 7704 7704 "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", 7705 7705 "dev": true, 7706 7706 "requires": { ··· 7725 7725 }, 7726 7726 "shelljs": { 7727 7727 "version": "0.2.6", 7728 7728 - "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.2.6.tgz", 7728 7728 + "resolved": "http://registry.npmjs.org/shelljs/-/shelljs-0.2.6.tgz", 7729 7729 "integrity": "sha1-kEktcv/MgVmXa6umL7D2iE8MM3g=", 7730 7730 "dev": true 7731 7731 }, ··· 7920 7920 }, 7921 7921 "socket.io-parser": { 7922 7922 "version": "3.2.0", 7923 7923 - "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.2.0.tgz", 7923 7923 + "resolved": "http://registry.npmjs.org/socket.io-parser/-/socket.io-parser-3.2.0.tgz", 7924 7924 "integrity": "sha512-FYiBx7rc/KORMJlgsXysflWx/RIvtqZbyGLlHZvjfmPTPeuD/I8MaW7cfFrj5tRltICJdgwflhfZ3NVVbVLFQA==", 7925 7925 "dev": true, 7926 7926 "requires": { ··· 8223 8223 }, 8224 8224 "string_decoder": { 8225 8225 "version": "1.1.1", 8226 8226 - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", 8226 8226 + "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", 8227 8227 "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", 8228 8228 "requires": { 8229 8229 "safe-buffer": "~5.1.0" ··· 8231 8231 }, 8232 8232 "strip-ansi": { 8233 8233 "version": "3.0.1", 8234 8234 - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", 8234 8234 + "resolved": "http://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", 8235 8235 "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", 8236 8236 "requires": { 8237 8237 "ansi-regex": "^2.0.0" ··· 8248 8248 }, 8249 8249 "strip-eof": { 8250 8250 "version": "1.0.0", 8251 8251 - "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", 8251 8251 + "resolved": "http://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", 8252 8252 "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", 8253 8253 "dev": true 8254 8254 }, ··· 8539 8539 }, 8540 8540 "through2": { 8541 8541 "version": "2.0.1", 8542 8542 - "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.1.tgz", 8542 8542 + "resolved": "http://registry.npmjs.org/through2/-/through2-2.0.1.tgz", 8543 8543 "integrity": "sha1-OE51MU1J8y3hLuu4E2uOtrXVnak=", 8544 8544 "dev": true, 8545 8545 "requires": { ··· 8555 8555 }, 8556 8556 "readable-stream": { 8557 8557 "version": "2.0.6", 8558 8558 - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz", 8558 8558 + "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz", 8559 8559 "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=", 8560 8560 "dev": true, 8561 8561 "requires": { ··· 8569 8569 }, 8570 8570 "string_decoder": { 8571 8571 "version": "0.10.31", 8572 8572 - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", 8572 8572 + "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", 8573 8573 "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=", 8574 8574 "dev": true 8575 8575 } ··· 8801 8801 }, 8802 8802 "lodash": { 8803 8803 "version": "1.3.1", 8804 8804 - "resolved": "https://registry.npmjs.org/lodash/-/lodash-1.3.1.tgz", 8804 8804 + "resolved": "http://registry.npmjs.org/lodash/-/lodash-1.3.1.tgz", 8805 8805 "integrity": "sha1-pGY7U2hriV/wdOK6UE37dqjit3A=", 8806 8806 "dev": true 8807 8807 }, ··· 8887 8887 }, 8888 8888 "underscore.string": { 8889 8889 "version": "2.2.1", 8890 8890 - "resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.2.1.tgz", 8890 8890 + "resolved": "http://registry.npmjs.org/underscore.string/-/underscore.string-2.2.1.tgz", 8891 8891 "integrity": "sha1-18D6KvXVoaZ/QlPa7pgTLnM/Dxk=", 8892 8892 "dev": true 8893 8893 }, ··· 9370 9370 }, 9371 9371 "tty-browserify": { 9372 9372 "version": "0.0.0", 9373 9373 - "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", 9373 9373 + "resolved": "http://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", 9374 9374 "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=", 9375 9375 "dev": true 9376 9376 }, ··· 9797 9797 }, 9798 9798 "vm-browserify": { 9799 9799 "version": "0.0.4", 9800 9800 - "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", 9800 9800 + "resolved": "http://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", 9801 9801 "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=", 9802 9802 "dev": true, 9803 9803 "requires": { ··· 11769 11769 }, 11770 11770 "wrap-ansi": { 11771 11771 "version": "2.1.0", 11772 11772 - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", 11772 11772 + "resolved": "http://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", 11773 11773 "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", 11774 11774 "dev": true, 11775 11775 "requires": { ··· 11825 11825 }, 11826 11826 "xmlbuilder": { 11827 11827 "version": "9.0.7", 11828 11828 - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz", 11828 11828 + "resolved": "http://registry.npmjs.org/xmlbuilder/-/xmlbuilder-9.0.7.tgz", 11829 11829 "integrity": "sha1-Ey7mPS7FVlxVfiD0wi35rKaGsQ0=", 11830 11830 "dev": true 11831 11831 },

+235 -145

src/engine/Actor.ts

Reviewed

··· 1 1 - import { Physics } from './Physics'; 2 1 import { Class } from './Class'; 3 2 import { BoundingBox } from './Collision/BoundingBox'; 4 3 import { Texture } from './Resources/Texture'; ··· 35 34 import { ActionContext } from './Actions/ActionContext'; 36 35 import { ActionQueue } from './Actions/Action'; 37 36 import { Vector } from './Algebra'; 38 38 - import { CollisionArea } from './Collision/CollisionArea'; 37 37 + import { CollisionShape } from './Collision/CollisionShape'; 39 38 import { Body } from './Collision/Body'; 40 39 import { Side } from './Collision/Side'; 41 40 import { Eventable } from './Interfaces/Evented'; ··· 46 45 import * as Util from './Util/Util'; 47 46 import * as Events from './Events'; 48 47 import { PointerEvents } from './Interfaces/PointerEvents'; 48 48 + import { CollisionType } from './Collision/CollisionType'; 49 49 + import { obsolete } from './Util/Decorators'; 50 50 + import { Collider } from './Collision/Collider'; 51 51 + import { Shape } from './Collision/Shape'; 52 52 + 53 53 + export function isActor(x: any): x is Actor { 54 54 + return x instanceof Actor; 55 55 + } 49 56 50 57 /** 51 58 * [[include:Constructors.md]] ··· 62 69 color?: Color; 63 70 visible?: boolean; 64 71 body?: Body; 65 65 - collisionType?: CollisionType; 66 72 } 67 73 68 74 export interface ActorDefaults { ··· 95 101 * The physics body the is associated with this actor. The body is the container for all physical properties, like position, velocity, 96 102 * acceleration, mass, inertia, etc. 97 103 */ 98 98 - public body: Body = new Body(this); 104 104 + public get body(): Body { 105 105 + return this._body; 106 106 + } 107 107 + 108 108 + public set body(body: Body) { 109 109 + this._body = body; 110 110 + this._body.actor = this; 111 111 + } 112 112 + 113 113 + private _body: Body; 99 114 100 115 /** 101 101 - * Gets the collision area shape to use for collision possible options are [CircleArea|circles], [PolygonArea|polygons], and 102 102 - * [EdgeArea|edges]. 116 116 + * Gets the collision geometry shape to use for collision possible options are [Circle|circles], [ConvexPolygon|polygons], and 117 117 + * [Edge|edges]. 118 118 + * @obsolete Use Actor.body.collider.shape, collisionArea will be removed in v0.24.0 103 119 */ 104 104 - public get collisionArea(): CollisionArea { 105 105 - return this.body.collisionArea; 120 120 + @obsolete({ message: 'Actor.collisionArea will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.shape' }) 121 121 + public get collisionArea(): CollisionShape { 122 122 + return this.body.collider.shape; 106 123 } 107 124 108 125 /** 109 109 - * Gets the collision area shape to use for collision possible options are [CircleArea|circles], [PolygonArea|polygons], and 110 110 - * [EdgeArea|edges]. 126 126 + * Gets the collision geometry shape to use for collision possible options are [Circle|circles], [ConvexPolygon|polygons], and 127 127 + * [Edge|edges]. 128 128 + * @obsolete use Actor.body.collider.shape, collisionArea will be removed in v0.24.0 111 129 */ 112 112 - public set collisionArea(area: CollisionArea) { 113 113 - this.body.collisionArea = area; 130 130 + public set collisionArea(area: CollisionShape) { 131 131 + this.body.collider.shape = area; 114 132 } 115 133 116 134 /** 117 135 * Gets the x position of the actor relative to it's parent (if any) 136 136 + * @obsolete ex.Actor.x will be removed in v0.24.0, use ex.Actor.pos.x 118 137 */ 138 138 + @obsolete({ message: 'ex.Actor.x will be removed in v0.24.0', alternateMethod: 'ex.Actor.pos.x, or ex.Actor.body.pos.x' }) 119 139 public get x(): number { 120 140 return this.body.pos.x; 121 141 } 122 142 123 143 /** 124 144 * Sets the x position of the actor relative to it's parent (if any) 145 145 + * @obsolete ex.Actor.x will be removed in v0.24.0, use ex.Actor.pos.x 125 146 */ 126 147 public set x(theX: number) { 127 148 this.body.pos.x = theX; ··· 129 150 130 151 /** 131 152 * Gets the y position of the actor relative to it's parent (if any) 153 153 + * @obsolete ex.Actor.y will be removed in v0.24.0, use ex.Actor.pos.y 132 154 */ 155 155 + @obsolete({ message: 'ex.Actor.y will be removed in v0.24.0', alternateMethod: 'ex.Actor.pos.y, or ex.Actor.body.pos.y' }) 133 156 public get y(): number { 134 157 return this.body.pos.y; 135 158 } 136 159 137 160 /** 138 161 * Sets the y position of the actor relative to it's parent (if any) 162 162 + * @obsolete ex.Actor.y will be removed in v0.24.0, use ex.Actor.pos.y 139 163 */ 140 164 public set y(theY: number) { 141 165 this.body.pos.y = theY; ··· 198 222 } 199 223 200 224 /** 201 201 - * Gets/sets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]]. 202 202 - */ 203 203 - public oldAcc: Vector = Vector.Zero; 204 204 - 205 205 - /** 206 225 * Gets the acceleration vector of the actor in pixels/second/second. An acceleration pointing down such as (0, 100) may be 207 226 * useful to simulate a gravitational effect. 208 227 */ ··· 218 237 } 219 238 220 239 /** 240 240 + * Sets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]]. 241 241 + */ 242 242 + public set oldAcc(theAcc: Vector) { 243 243 + this.body.oldAcc.setTo(theAcc.x, theAcc.y); 244 244 + } 245 245 + 246 246 + /** 247 247 + * Gets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]]. 248 248 + */ 249 249 + public get oldAcc(): Vector { 250 250 + return this.body.oldAcc; 251 251 + } 252 252 + 253 253 + /** 221 254 * Gets the rotation of the actor in radians. 1 radian = 180/PI Degrees. 222 255 */ 223 256 public get rotation(): number { ··· 247 280 248 281 /** 249 282 * Gets the current torque applied to the actor. Torque can be thought of as rotational force 283 283 + * @obsolete ex.Actor.torque will be removed in v0.24.0, use ex.Actor.body.torque 250 284 */ 285 285 + @obsolete({ message: 'ex.Actor.torque will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.torque' }) 251 286 public get torque() { 252 287 return this.body.torque; 253 288 } 254 289 255 290 /** 256 291 * Sets the current torque applied to the actor. Torque can be thought of as rotational force 292 292 + * @obsolete ex.Actor.torque will be removed in v0.24.0, use ex.Actor.body.torque 257 293 */ 258 294 public set torque(theTorque: number) { 259 295 this.body.torque = theTorque; ··· 261 297 262 298 /** 263 299 * Get the current mass of the actor, mass can be thought of as the resistance to acceleration. 300 300 + * @obsolete ex.Actor.mass will be removed in v0.24.0, use ex.Actor.body.collider.mass 264 301 */ 302 302 + @obsolete({ message: 'ex.Actor.mass will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.collider.mass' }) 265 303 public get mass() { 266 266 - return this.body.mass; 304 304 + return this.body.collider.mass; 267 305 } 268 306 269 307 /** 270 308 * Sets the mass of the actor, mass can be thought of as the resistance to acceleration. 309 309 + * @obsolete ex.Actor.mass will be removed in v0.24.0, use ex.Actor.body.collider.mass 271 310 */ 272 311 public set mass(theMass: number) { 273 273 - this.body.mass = theMass; 312 312 + this.body.collider.mass = theMass; 274 313 } 275 314 276 315 /** 277 316 * Gets the current moment of inertia, moi can be thought of as the resistance to rotation. 317 317 + * @obsolete ex.Actor.moi will be removed in v0.24.0, use ex.Actor.body.collider.inertia 278 318 */ 319 319 + @obsolete({ message: 'ex.Actor.moi will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.collider.inertia' }) 279 320 public get moi() { 280 280 - return this.body.moi; 321 321 + return this.body.collider.inertia; 281 322 } 282 323 283 324 /** 284 325 * Sets the current moment of inertia, moi can be thought of as the resistance to rotation. 326 326 + * @obsolete ex.Actor.moi will be removed in v0.24.0, use ex.Actor.body.collider.inertia 285 327 */ 286 328 public set moi(theMoi: number) { 287 287 - this.body.moi = theMoi; 329 329 + this.body.collider.inertia = theMoi; 288 330 } 289 331 290 332 /** 291 333 * Gets the coefficient of friction on this actor, this can be thought of as how sticky or slippery an object is. 334 334 + * @obsolete ex.Actor.friction will be removed in v0.24.0, use ex.Actor.body.collider.friction 292 335 */ 336 336 + @obsolete({ message: 'ex.Actor.friction will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.collider.friction' }) 293 337 public get friction() { 294 294 - return this.body.friction; 338 338 + return this.body.collider.friction; 295 339 } 296 340 297 341 /** 298 342 * Sets the coefficient of friction of this actor, this can ve thought of as how stick or slippery an object is. 299 343 */ 300 344 public set friction(theFriction: number) { 301 301 - this.body.friction = theFriction; 345 345 + this.body.collider.friction = theFriction; 302 346 } 303 347 304 348 /** 305 349 * Gets the coefficient of restitution of this actor, represents the amount of energy preserved after collision. Think of this 306 350 * as bounciness. 351 351 + * @obsolete ex.Actor.restitution will be removed in v0.24.0, use ex.Actor.body.collider.restitution 307 352 */ 353 353 + @obsolete({ message: 'ex.Actor.restitution will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.collider.bounciness' }) 308 354 public get restitution() { 309 309 - return this.body.restitution; 355 355 + return this.body.collider.bounciness; 310 356 } 311 357 312 358 /** 313 359 * Sets the coefficient of restitution of this actor, represents the amount of energy preserved after collision. Think of this 314 360 * as bounciness. 361 361 + * @obsolete ex.Actor.restitution will be removed in v0.24.0, use ex.Actor.body.collider.restitution 315 362 */ 316 363 public set restitution(theRestitution: number) { 317 317 - this.body.restitution = theRestitution; 364 364 + this.body.collider.bounciness = theRestitution; 318 365 } 319 366 320 367 /** ··· 334 381 private _width: number = 0; 335 382 336 383 /** 337 337 - * The scale vector of the actor 384 384 + * Gets the scale vector of the actor 338 385 */ 339 339 - public scale: Vector = Vector.One; 386 386 + public get scale(): Vector { 387 387 + return this.body.scale; 388 388 + } 340 389 341 390 /** 342 342 - * The scale of the actor last frame 391 391 + * Sets the scale vector of the actor 343 392 */ 344 344 - public oldScale: Vector = Vector.One; 393 393 + public set scale(scale: Vector) { 394 394 + this.body.scale = scale; 395 395 + this.width = this.width; 396 396 + } 345 397 346 398 /** 347 347 - * The x scalar velocity of the actor in scale/second 399 399 + * Gets the old scale of the actor last frame 400 400 + */ 401 401 + public get oldScale(): Vector { 402 402 + return this.body.oldScale; 403 403 + } 404 404 + 405 405 + /** 406 406 + * Sets the the old scale of the acotr last frame 348 407 */ 349 349 - public sx: number = 0; //scale/sec 408 408 + public set oldScale(scale: Vector) { 409 409 + this.body.oldScale = scale; 410 410 + } 411 411 + 412 412 + /** 413 413 + * Gets the x scalar velocity of the actor in scale/second 414 414 + */ 415 415 + public get sx(): number { 416 416 + return this.body.sx; 417 417 + } 418 418 + 419 419 + /** 420 420 + * Sets the x scalar velocity of the actor in scale/second 421 421 + */ 422 422 + public set sx(scalePerSecondX: number) { 423 423 + this.body.sx = scalePerSecondX; 424 424 + } 425 425 + 426 426 + /** 427 427 + * Gets the y scalar velocity of the actor in scale/second 428 428 + */ 429 429 + public get sy(): number { 430 430 + return this.body.sy; 431 431 + } 432 432 + 350 433 /** 351 351 - * The y scalar velocity of the actor in scale/second 434 434 + * Sets the y scale velocity of the actor in scale/second 352 435 */ 353 353 - public sy: number = 0; //scale/sec 436 436 + public set sy(scalePerSecondY: number) { 437 437 + this.body.sy = scalePerSecondY; 438 438 + } 354 439 355 440 /** 356 441 * Indicates whether the actor is physically in the viewport ··· 396 481 * The children of this actor 397 482 */ 398 483 public children: Actor[] = []; 484 484 + 399 485 /** 400 486 * Gets or sets the current collision type of this actor. By 401 487 * default it is ([[CollisionType.PreventCollision]]). 488 488 + * @obsolete ex.Actor.collisionType will be removed in v0.24.0, use ex.Actor.body.collider.type 402 489 */ 403 403 - public collisionType: CollisionType = CollisionType.PreventCollision; 404 404 - public collisionGroups: string[] = []; 490 490 + @obsolete({ message: 'ex.Actor.collisionType will be removed in v0.24.0', alternateMethod: 'ex.Actor.body.collider.type' }) 491 491 + public get collisionType(): CollisionType { 492 492 + return this.body.collider.type; 493 493 + } 405 494 406 495 /** 407 407 - * Flag to be set when any property change would result in a geometry recalculation 408 408 - * @internal 496 496 + * Gets or sets the current collision type of this actor. By 497 497 + * default it is ([[CollisionType.PreventCollision]]). 498 498 + * @obsolete ex.Actor.collisionType will be removed in v0.24.0, use ex.Actor.body.collider.type 409 499 */ 410 410 - private _geometryDirty: boolean = false; 500 500 + public set collisionType(type: CollisionType) { 501 501 + this.body.collider.type = type; 502 502 + } 503 503 + 504 504 + public collisionGroups: string[] = []; 411 505 412 506 private _collisionHandlers: { [key: string]: { (actor: Actor): void }[] } = {}; 413 507 private _isInitialized: boolean = false; ··· 471 565 constructor(xOrConfig?: number | ActorArgs, y?: number, width?: number, height?: number, color?: Color) { 472 566 super(); 473 567 568 568 + let shouldInitializeBody = true; 474 569 if (xOrConfig && typeof xOrConfig === 'object') { 475 570 const config = xOrConfig; 476 571 xOrConfig = config.pos ? config.pos.x : config.x; 477 572 y = config.pos ? config.pos.y : config.y; 478 573 width = config.width; 479 574 height = config.height; 575 575 + 576 576 + if (config.body) { 577 577 + shouldInitializeBody = false; 578 578 + this.body = config.body; 579 579 + } 480 580 } 481 581 482 482 - this.pos.x = <number>xOrConfig || 0; 483 483 - this.pos.y = y || 0; 582 582 + // initialize default options 583 583 + this._initDefaults(); 584 584 + 585 585 + // Body and collider bounds are still determined by actor width/height 484 586 this._width = width || 0; 485 587 this._height = height || 0; 588 588 + 589 589 + // Initialize default collider to be a box 590 590 + if (shouldInitializeBody) { 591 591 + this.body = new Body({ 592 592 + collider: new Collider({ 593 593 + type: CollisionType.Passive, 594 594 + shape: Shape.Box(this._width, this._height, this.anchor) 595 595 + }) 596 596 + }); 597 597 + } 598 598 + 599 599 + // Position uses body to store values must be initialized after body 600 600 + this.pos.x = <number>xOrConfig || 0; 601 601 + this.pos.y = y || 0; 602 602 + 486 603 if (color) { 487 604 this.color = color; 488 605 // set default opacity of an actor to the color ··· 497 614 // Build the action queue 498 615 this.actionQueue = new ActionQueue(this); 499 616 this.actions = new ActionContext(this); 500 500 - 501 501 - // initialize default options 502 502 - this._initDefaults(); 503 503 - 504 504 - // Initialize default collision area to be box 505 505 - this.body.useBoxCollision(); 506 617 } 507 618 508 619 /** ··· 870 981 * @param actor The child actor to add 871 982 */ 872 983 public add(actor: Actor) { 873 873 - actor.collisionType = CollisionType.PreventCollision; 984 984 + actor.body.collider.type = CollisionType.PreventCollision; 874 985 if (Util.addItemToArray(actor, this.children)) { 875 986 actor.parent = this; 876 987 } ··· 993 1104 /** 994 1105 * Get the center point of an actor 995 1106 */ 1107 1107 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.center' }) 996 1108 public getCenter(): Vector { 997 997 - return new Vector( 998 998 - this.pos.x + this.getWidth() / 2 - this.anchor.x * this.getWidth(), 999 999 - this.pos.y + this.getHeight() / 2 - this.anchor.y * this.getHeight() 1000 1000 - ); 1109 1109 + return new Vector(this.pos.x + this.width / 2 - this.anchor.x * this.width, this.pos.y + this.height / 2 - this.anchor.y * this.height); 1110 1110 + } 1111 1111 + 1112 1112 + /** 1113 1113 + * Get the center point of an actor 1114 1114 + */ 1115 1115 + public get center(): Vector { 1116 1116 + return new Vector(this.pos.x + this.width / 2 - this.anchor.x * this.width, this.pos.y + this.height / 2 - this.anchor.y * this.height); 1117 1117 + } 1118 1118 + 1119 1119 + public get width() { 1120 1120 + return this._width * this.getGlobalScale().x; 1121 1121 + } 1122 1122 + 1123 1123 + public set width(width: number) { 1124 1124 + this._width = width / this.scale.x; 1125 1125 + this.body.collider.shape = Shape.Box(this._width, this._height, this.anchor); 1126 1126 + this.body.markCollisionShapeDirty(); 1001 1127 } 1128 1128 + 1002 1129 /** 1003 1130 * Gets the calculated width of an actor, factoring in scale 1004 1131 */ 1132 1132 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.width' }) 1005 1133 public getWidth() { 1006 1006 - return this._width * this.getGlobalScale().x; 1134 1134 + return this.width; 1007 1135 } 1008 1136 /** 1009 1137 * Sets the width of an actor, factoring in the current scale 1010 1138 */ 1139 1139 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.width' }) 1011 1140 public setWidth(width: number) { 1012 1012 - this._width = width / this.scale.x; 1013 1013 - this._geometryDirty = true; 1141 1141 + this.width = width; 1142 1142 + } 1143 1143 + 1144 1144 + public get height() { 1145 1145 + return this._height * this.getGlobalScale().y; 1014 1146 } 1147 1147 + 1148 1148 + public set height(height: number) { 1149 1149 + this._height = height / this.scale.y; 1150 1150 + this.body.collider.shape = Shape.Box(this._width, this._height, this.anchor); 1151 1151 + this.body.markCollisionShapeDirty(); 1152 1152 + } 1153 1153 + 1015 1154 /** 1016 1155 * Gets the calculated height of an actor, factoring in scale 1017 1156 */ 1157 1157 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.height' }) 1018 1158 public getHeight() { 1019 1019 - return this._height * this.getGlobalScale().y; 1159 1159 + return this.height; 1020 1160 } 1021 1161 /** 1022 1162 * Sets the height of an actor, factoring in the current scale 1023 1163 */ 1164 1164 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.height' }) 1024 1165 public setHeight(height: number) { 1025 1025 - this._height = height / this.scale.y; 1026 1026 - this._geometryDirty = true; 1166 1166 + this.height = height; 1027 1167 } 1168 1168 + 1028 1169 /** 1029 1170 * Gets the left edge of the actor 1030 1171 */ 1172 1172 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds.left' }) 1031 1173 public getLeft() { 1032 1174 return this.getBounds().left; 1033 1175 } 1176 1176 + 1034 1177 /** 1035 1178 * Gets the right edge of the actor 1036 1179 */ 1180 1180 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds.right' }) 1037 1181 public getRight() { 1038 1182 return this.getBounds().right; 1039 1183 } 1184 1184 + 1040 1185 /** 1041 1186 * Gets the top edge of the actor 1042 1187 */ 1188 1188 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds.top' }) 1043 1189 public getTop() { 1044 1190 return this.getBounds().top; 1045 1191 } 1192 1192 + 1046 1193 /** 1047 1194 * Gets the bottom edge of the actor 1048 1195 */ 1196 1196 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds.bottom' }) 1049 1197 public getBottom() { 1050 1198 return this.getBounds().bottom; 1051 1199 } ··· 1124 1272 /** 1125 1273 * Returns the actor's [[BoundingBox]] calculated for this instant in world space. 1126 1274 */ 1275 1275 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds' }) 1127 1276 public getBounds(rotated: boolean = true): BoundingBox { 1128 1277 // todo cache bounding box 1129 1278 const anchor = this._getCalculatedAnchor(); 1130 1279 const pos = this.getWorldPos(); 1131 1280 1132 1132 - const bb = new BoundingBox(pos.x - anchor.x, pos.y - anchor.y, pos.x + this.getWidth() - anchor.x, pos.y + this.getHeight() - anchor.y); 1281 1281 + const bb = new BoundingBox(pos.x - anchor.x, pos.y - anchor.y, pos.x + this.width - anchor.x, pos.y + this.height - anchor.y); 1133 1282 1134 1283 return rotated ? bb.rotate(this.rotation, pos) : bb; 1135 1284 } ··· 1137 1286 /** 1138 1287 * Returns the actor's [[BoundingBox]] relative to the actor's position. 1139 1288 */ 1289 1289 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.localBounds' }) 1140 1290 public getRelativeBounds(rotated: boolean = true): BoundingBox { 1141 1291 // todo cache bounding box 1142 1292 const anchor = this._getCalculatedAnchor(); 1143 1143 - const bb = new BoundingBox(-anchor.x, -anchor.y, this.getWidth() - anchor.x, this.getHeight() - anchor.y); 1293 1293 + const bb = new BoundingBox(-anchor.x, -anchor.y, this.width - anchor.x, this.height - anchor.y); 1144 1294 1145 1295 return rotated ? bb.rotate(this.rotation) : bb; 1146 1296 } ··· 1148 1298 /** 1149 1299 * Returns the actors unrotated geometry in world coordinates 1150 1300 */ 1301 1301 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.bounds.getPoints()' }) 1151 1302 public getGeometry(): Vector[] { 1152 1303 return this.getBounds(false).getPoints(); 1153 1304 } ··· 1155 1306 /** 1156 1307 * Return the actor's unrotated geometry relative to the actor's position 1157 1308 */ 1309 1309 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Actor.body.collider.localBounds.getPoints()' }) 1158 1310 public getRelativeGeometry(): Vector[] { 1159 1311 return this.getRelativeBounds(false).getPoints(); 1160 1312 } 1161 1313 1162 1314 /** 1163 1163 - * Indicates that the actor's collision geometry needs to be recalculated for accurate collisions 1164 1164 - */ 1165 1165 - public get isGeometryDirty() { 1166 1166 - return this._geometryDirty; 1167 1167 - } 1168 1168 - 1169 1169 - /** 1170 1315 * Tests whether the x/y specified are contained in the actor 1171 1316 * @param x X coordinate to test (in world coordinates) 1172 1317 * @param y Y coordinate to test (in world coordinates) 1173 1318 * @param recurse checks whether the x/y are contained in any child actors (if they exist). 1174 1319 */ 1175 1320 public contains(x: number, y: number, recurse: boolean = false): boolean { 1176 1176 - const containment = this.getBounds().contains(new Vector(x, y)); 1321 1321 + // These shenanigans are to handle child actor containment, 1322 1322 + // the only time getWorldPos and pos are different is a child actor 1323 1323 + const childShift = this.getWorldPos().sub(this.pos); 1324 1324 + const containment = this.body.collider.bounds.translate(childShift).contains(new Vector(x, y)); 1177 1325 1178 1326 if (recurse) { 1179 1327 return ( ··· 1190 1338 /** 1191 1339 * Returns the side of the collision based on the intersection 1192 1340 * @param intersect The displacement vector returned by a collision 1341 1341 + * @obsolete Actor.getSideFromIntersect will be removed in v0.24.0, use [[BoundingBox.sideFromIntersection]] 1193 1342 */ 1343 1343 + @obsolete({ message: 'Actor.getSideFromIntersect will be removed in v0.24.0', alternateMethod: 'BoundingBox.sideFromIntersection' }) 1194 1344 public getSideFromIntersect(intersect: Vector) { 1195 1345 if (intersect) { 1196 1346 if (Math.abs(intersect.x) > Math.abs(intersect.y)) { ··· 1210 1360 /** 1211 1361 * Test whether the actor has collided with another actor, returns the side of the current actor that collided. 1212 1362 * @param actor The other actor to test 1363 1363 + * @obsolete Actor.collidesWithSide will be removed in v0.24.0, use [[Actor.bounds.intersectWithSide]] 1213 1364 */ 1365 1365 + @obsolete({ message: 'Actor.collidesWithSide will be removed in v0.24.0', alternateMethod: 'Actor.bounds.intersectWithSide' }) 1214 1366 public collidesWithSide(actor: Actor): Side { 1215 1367 const separationVector = this.collides(actor); 1216 1368 if (!separationVector) { ··· 1234 1386 * Test whether the actor has collided with another actor, returns the intersection vector on collision. Returns 1235 1387 * `null` when there is no collision; 1236 1388 * @param actor The other actor to test 1389 1389 + * @obsolete Actor.collides will be removed in v0.24.0, use [[Actor.bounds.interesect]] to get boudings intersection, 1390 1390 + * or [[Actor.body.collider.collide]] to collide with another collider 1237 1391 */ 1392 1392 + @obsolete({ message: 'Actor.collides will be removed in v0.24.0', alternateMethod: 'Actor.bounds.intersect or Actor.' }) 1238 1393 public collides(actor: Actor): Vector { 1239 1239 - const bounds = this.getBounds(); 1240 1240 - const otherBounds = actor.getBounds(); 1241 1241 - const intersect = bounds.collides(otherBounds); 1394 1394 + const bounds = this.body.collider.bounds; 1395 1395 + const otherBounds = actor.body.collider.bounds; 1396 1396 + const intersect = bounds.intersect(otherBounds); 1242 1397 return intersect; 1243 1398 } 1399 1399 + 1244 1400 /** 1245 1401 * Register a handler to fire when this actor collides with another in a specified group 1246 1402 * @param group The group name to listen for ··· 1274 1430 // #endregion 1275 1431 1276 1432 private _getCalculatedAnchor(): Vector { 1277 1277 - return new Vector(this.getWidth() * this.anchor.x, this.getHeight() * this.anchor.y); 1433 1433 + return new Vector(this.width * this.anchor.x, this.height * this.anchor.y); 1278 1434 } 1279 1435 1280 1436 protected _reapplyEffects(drawing: Drawable) { ··· 1283 1439 } 1284 1440 1285 1441 // #region Update 1286 1286 - /** 1287 1287 - * Perform euler integration at the specified time step 1288 1288 - */ 1289 1289 - public integrate(delta: number) { 1290 1290 - // Update placements based on linear algebra 1291 1291 - const seconds = delta / 1000; 1292 1292 - 1293 1293 - const totalAcc = this.acc.clone(); 1294 1294 - // Only active vanilla actors are affected by global acceleration 1295 1295 - if (this.collisionType === CollisionType.Active) { 1296 1296 - totalAcc.addEqual(Physics.acc); 1297 1297 - } 1298 1298 - 1299 1299 - this.vel.addEqual(totalAcc.scale(seconds)); 1300 1300 - this.pos.addEqual(this.vel.scale(seconds)).addEqual(totalAcc.scale(0.5 * seconds * seconds)); 1301 1301 - 1302 1302 - this.rx += this.torque * (1.0 / this.moi) * seconds; 1303 1303 - this.rotation += this.rx * seconds; 1304 1304 - 1305 1305 - this.scale.x += (this.sx * delta) / 1000; 1306 1306 - this.scale.y += (this.sy * delta) / 1000; 1307 1307 - 1308 1308 - if (!this.scale.equals(this.oldScale)) { 1309 1309 - // change in scale effects the geometry 1310 1310 - this._geometryDirty = true; 1311 1311 - } 1312 1312 - 1313 1313 - // Update physics body 1314 1314 - this.body.update(); 1315 1315 - this._geometryDirty = false; 1316 1316 - } 1317 1442 1318 1443 /** 1319 1444 * Called by the Engine, updates the state of the actor ··· 1339 1464 this._effectsDirty = true; 1340 1465 } 1341 1466 1342 1342 - // Capture old values before integration step updates them 1343 1343 - this.oldVel.setTo(this.vel.x, this.vel.y); 1344 1344 - this.oldPos.setTo(this.pos.x, this.pos.y); 1345 1345 - this.oldAcc.setTo(this.acc.x, this.acc.y); 1346 1346 - this.oldScale.setTo(this.scale.x, this.scale.y); 1467 1467 + // capture old transform 1468 1468 + this.body.captureOldTransform(); 1347 1469 1348 1470 // Run Euler integration 1349 1349 - this.integrate(delta); 1471 1471 + this.body.integrate(delta); 1350 1472 1351 1473 // Update actor pipeline (movement, collision detection, event propagation, offscreen culling) 1352 1474 for (const trait of this.traits) { ··· 1434 1556 1435 1557 this.currentDrawing.draw(ctx, offsetX, offsetY); 1436 1558 } else { 1437 1437 - if (this.color) { 1438 1438 - ctx.fillStyle = this.color.toString(); 1439 1439 - ctx.fillRect(0, 0, this._width, this._height); 1559 1559 + if (this.color && this.body && this.body.collider && this.body.collider.shape) { 1560 1560 + this.body.collider.shape.draw(ctx, this.color, new Vector(this.width * this.anchor.x, this.height * this.anchor.y)); 1440 1561 } 1441 1562 } 1442 1563 ctx.restore(); ··· 1500 1621 public debugDraw(ctx: CanvasRenderingContext2D) { 1501 1622 this.emit('predebugdraw', new PreDebugDrawEvent(ctx, this)); 1502 1623 1503 1503 - this.body.debugDraw(ctx); 1624 1624 + this.body.collider.debugDraw(ctx); 1504 1625 1505 1626 // Draw actor bounding box 1506 1506 - const bb = this.getBounds(); 1627 1627 + const bb = this.body.collider.bounds; 1507 1628 bb.debugDraw(ctx); 1508 1629 1509 1630 // Draw actor Id ··· 1526 1647 // Unit Circle debug draw 1527 1648 ctx.strokeStyle = Color.Yellow.toString(); 1528 1649 ctx.beginPath(); 1529 1529 - const radius = Math.min(this.getWidth(), this.getHeight()); 1650 1650 + const radius = Math.min(this.width, this.height); 1530 1651 ctx.arc(this.getWorldPos().x, this.getWorldPos().y, radius, 0, Math.PI * 2); 1531 1652 ctx.closePath(); 1532 1653 ctx.stroke(); ··· 1597 1718 super(xOrConfig, y, width, height, color); 1598 1719 } 1599 1720 } 1600 1600 - 1601 1601 - /** 1602 1602 - * An enum that describes the types of collisions actors can participate in 1603 1603 - */ 1604 1604 - export enum CollisionType { 1605 1605 - /** 1606 1606 - * Actors with the `PreventCollision` setting do not participate in any 1607 1607 - * collisions and do not raise collision events. 1608 1608 - */ 1609 1609 - PreventCollision, 1610 1610 - /** 1611 1611 - * Actors with the `Passive` setting only raise collision events, but are not 1612 1612 - * influenced or moved by other actors and do not influence or move other actors. 1613 1613 - */ 1614 1614 - Passive, 1615 1615 - /** 1616 1616 - * Actors with the `Active` setting raise collision events and participate 1617 1617 - * in collisions with other actors and will be push or moved by actors sharing 1618 1618 - * the `Active` or `Fixed` setting. 1619 1619 - */ 1620 1620 - Active, 1621 1621 - /** 1622 1622 - * Actors with the `Fixed` setting raise collision events and participate in 1623 1623 - * collisions with other actors. Actors with the `Fixed` setting will not be 1624 1624 - * pushed or moved by other actors sharing the `Fixed`. Think of Fixed 1625 1625 - * actors as "immovable/onstoppable" objects. If two `Fixed` actors meet they will 1626 1626 - * not be pushed or moved by each other, they will not interact except to throw 1627 1627 - * collision events. 1628 1628 - */ 1629 1629 - Fixed 1630 1630 - }

+10 -3

src/engine/Algebra.ts

Reviewed

··· 1 1 import { Engine } from './Engine'; 2 2 import * as Util from './Util/Util'; 3 3 + import { Clonable } from './Interfaces/Clonable'; 3 4 4 5 /** 5 6 * A 2D vector on a plane. 6 7 */ 7 7 - export class Vector { 8 8 + export class Vector implements Clonable<Vector> { 8 9 /** 9 10 * A (0, 0) vector 10 11 */ ··· 151 152 * Scales a vector's by a factor of size 152 153 * @param size The factor to scale the magnitude by 153 154 */ 154 154 - public scale(size: number): Vector { 155 155 - return new Vector(this.x * size, this.y * size); 155 155 + public scale(scale: Vector): Vector; 156 156 + public scale(size: number): Vector; 157 157 + public scale(sizeOrScale: number | Vector): Vector { 158 158 + if (sizeOrScale instanceof Vector) { 159 159 + return new Vector(this.x * sizeOrScale.x, this.y * sizeOrScale.y); 160 160 + } else { 161 161 + return new Vector(this.x * sizeOrScale, this.y * sizeOrScale); 162 162 + } 156 163 } 157 164 158 165 /**

+5 -5

src/engine/Camera.ts

Reviewed

··· 90 90 export class LockCameraToActorStrategy implements CameraStrategy<Actor> { 91 91 constructor(public target: Actor) {} 92 92 public action = (target: Actor, _cam: Camera, _eng: Engine, _delta: number) => { 93 93 - const center = target.getCenter(); 93 93 + const center = target.center; 94 94 return center; 95 95 }; 96 96 } ··· 101 101 export class LockCameraToActorAxisStrategy implements CameraStrategy<Actor> { 102 102 constructor(public target: Actor, public axis: Axis) {} 103 103 public action = (target: Actor, cam: Camera, _eng: Engine, _delta: number) => { 104 104 - const center = target.getCenter(); 104 104 + const center = target.center; 105 105 const currentFocus = cam.getFocus(); 106 106 if (this.axis === Axis.X) { 107 107 return new Vector(center.x, currentFocus.y); ··· 126 126 */ 127 127 constructor(public target: Actor, public cameraElasticity: number, public cameraFriction: number) {} 128 128 public action = (target: Actor, cam: Camera, _eng: Engine, _delta: number) => { 129 129 - const position = target.getCenter(); 129 129 + const position = target.center; 130 130 let focus = cam.getFocus(); 131 131 let cameraVel = new Vector(cam.dx, cam.dy); 132 132 ··· 157 157 */ 158 158 constructor(public target: Actor, public radius: number) {} 159 159 public action = (target: Actor, cam: Camera, _eng: Engine, _delta: number) => { 160 160 - const position = target.getCenter(); 160 160 + const position = target.center; 161 161 const focus = cam.getFocus(); 162 162 163 163 const direction = position.sub(focus); ··· 613 613 ctx.setLineDash([5, 15]); 614 614 ctx.lineWidth = 5; 615 615 ctx.strokeStyle = 'white'; 616 616 - ctx.strokeRect(this.viewport.left, this.viewport.top, this.viewport.getWidth(), this.viewport.getHeight()); 616 616 + ctx.strokeRect(this.viewport.left, this.viewport.top, this.viewport.width, this.viewport.height); 617 617 ctx.closePath(); 618 618 } 619 619

+199 -114

src/engine/Collision/Body.ts

Reviewed

··· 1 1 - import { Physics, CollisionResolutionStrategy } from './../Physics'; 2 2 - import { EdgeArea } from './EdgeArea'; 3 3 - import { CircleArea } from './CircleArea'; 4 4 - import { CollisionArea } from './CollisionArea'; 5 5 - import { PolygonArea } from './PolygonArea'; 6 6 - import { BoundingBox } from './BoundingBox'; 7 7 - import { Pair } from './Pair'; 8 8 - 9 1 import { Vector } from '../Algebra'; 10 2 import { Actor } from '../Actor'; 11 11 - import { Color } from '../Drawing/Color'; 12 12 - import * as DrawUtil from '../Util/DrawUtil'; 3 3 + import { Collider } from './Collider'; 4 4 + import { CollisionType } from './CollisionType'; 5 5 + import { Physics } from '../Physics'; 6 6 + import { obsolete } from '../Util/Decorators'; 7 7 + import { PreCollisionEvent, PostCollisionEvent, CollisionStartEvent, CollisionEndEvent } from '../Events'; 8 8 + import { Clonable } from '../Interfaces/Clonable'; 9 9 + import { Shape } from './Shape'; 13 10 14 14 - export class Body { 11 11 + export interface BodyOptions { 12 12 + /** 13 13 + * Optionally the actory associated with this body 14 14 + */ 15 15 + actor?: Actor; 16 16 + /** 17 17 + * An optional collider to use in this body, if none is specified a default Box collider will be created. 18 18 + */ 19 19 + collider?: Collider; 20 20 + } 21 21 + 22 22 + /** 23 23 + * Body describes all the physical properties pos, vel, acc, rotation, angular velocity 24 24 + */ 25 25 + export class Body implements Clonable<Body> { 26 26 + private _collider: Collider; 27 27 + public actor: Actor; 15 28 /** 16 29 * Constructs a new physics body associated with an actor 17 30 */ 18 18 - constructor(public actor: Actor) {} 31 31 + constructor({ actor, collider }: BodyOptions) { 32 32 + if (!actor && !collider) { 33 33 + throw new Error('An actor or collider are required to create a body'); 34 34 + } 35 35 + 36 36 + this.actor = actor; 37 37 + if (!collider && actor) { 38 38 + this.collider = this.useBoxCollider(actor.width, actor.height, actor.anchor); 39 39 + } else { 40 40 + this.collider = collider; 41 41 + } 42 42 + } 43 43 + 44 44 + public get id() { 45 45 + return this.actor ? this.actor.id : -1; 46 46 + } 19 47 20 48 /** 21 21 - * [[ICollisionArea|Collision area]] of this physics body, defines the shape for rigid body collision 49 49 + * Returns a clone of this body, not associated with any actor 22 50 */ 23 23 - public collisionArea: CollisionArea = null; 51 51 + public clone() { 52 52 + return new Body({ 53 53 + actor: null, 54 54 + collider: this.collider.clone() 55 55 + }); 56 56 + } 57 57 + 58 58 + public get active() { 59 59 + return this.actor ? !this.actor.isKilled() : false; 60 60 + } 61 61 + 62 62 + public get center() { 63 63 + return this.pos; 64 64 + } 65 65 + 66 66 + // TODO allow multiple colliders for a single body 67 67 + public set collider(collider: Collider) { 68 68 + if (collider) { 69 69 + this._collider = collider; 70 70 + this._collider.body = this; 71 71 + this._wireColliderEventsToActor(); 72 72 + } 73 73 + } 74 74 + 75 75 + public get collider(): Collider { 76 76 + return this._collider; 77 77 + } 24 78 25 79 /** 26 80 * The (x, y) position of the actor this will be in the middle of the actor if the ··· 51 105 public acc: Vector = new Vector(0, 0); 52 106 53 107 /** 108 108 + * Gets/sets the acceleration of the actor from the last frame. This does not include the global acc [[Physics.acc]]. 109 109 + */ 110 110 + public oldAcc: Vector = Vector.Zero; 111 111 + 112 112 + /** 54 113 * The current torque applied to the actor 55 114 */ 56 115 public torque: number = 0; 57 116 58 117 /** 59 59 - * The current mass of the actor, mass can be thought of as the resistance to acceleration. 118 118 + * The current "motion" of the actor, used to calculated sleep in the physics simulation 60 119 */ 61 61 - public mass: number = 1.0; 120 120 + public motion: number = 10; 62 121 63 122 /** 64 64 - * The current moment of inertia, moi can be thought of as the resistance to rotation. 123 123 + * Gets/sets the rotation of the body from the last frame. 65 124 */ 66 66 - public moi: number = 1000; 125 125 + public oldRotation: number = 0; // radians 67 126 68 127 /** 69 69 - * The current "motion" of the actor, used to calculated sleep in the physics simulation 128 128 + * The rotation of the actor in radians 70 129 */ 71 71 - public motion: number = 10; 130 130 + public rotation: number = 0; // radians 72 131 73 132 /** 74 74 - * The coefficient of friction on this actor 133 133 + * The scale vector of the actor 75 134 */ 76 76 - public friction: number = 0.99; 135 135 + public scale: Vector = Vector.One; 77 136 78 137 /** 79 79 - * The coefficient of restitution of this actor, represents the amount of energy preserved after collision 138 138 + * The scale of the actor last frame 80 139 */ 81 81 - public restitution: number = 0.2; 140 140 + public oldScale: Vector = Vector.One; 82 141 83 142 /** 84 84 - * The rotation of the actor in radians 143 143 + * The x scalar velocity of the actor in scale/second 144 144 + */ 145 145 + public sx: number = 0; //scale/sec 146 146 + /** 147 147 + * The y scalar velocity of the actor in scale/second 85 148 */ 86 86 - public rotation: number = 0; // radians 149 149 + public sy: number = 0; //scale/sec 87 150 88 151 /** 89 152 * The rotational velocity of the actor in radians/second 90 153 */ 91 154 public rx: number = 0; //radians/sec 155 155 + 156 156 + private _geometryDirty = false; 92 157 93 158 private _totalMtv: Vector = Vector.Zero; 94 159 ··· 108 173 } 109 174 110 175 /** 111 111 - * Returns the body's [[BoundingBox]] calculated for this instant in world space. 176 176 + * Flags the shape dirty and must be recalculated in world space 112 177 */ 113 113 - public getBounds(): BoundingBox { 114 114 - if (Physics.collisionResolutionStrategy === CollisionResolutionStrategy.Box) { 115 115 - return this.actor.getBounds(); 116 116 - } else { 117 117 - return this.collisionArea.getBounds(); 118 118 - } 178 178 + public markCollisionShapeDirty() { 179 179 + this._geometryDirty = true; 180 180 + } 181 181 + 182 182 + public get isColliderShapeDirty(): boolean { 183 183 + return this._geometryDirty; 119 184 } 120 185 121 186 /** 122 122 - * Returns the actor's [[BoundingBox]] relative to the actors position. 187 187 + * Sets the old versions of pos, vel, acc, and scale. 123 188 */ 124 124 - public getRelativeBounds(): BoundingBox { 125 125 - if (Physics.collisionResolutionStrategy === CollisionResolutionStrategy.Box) { 126 126 - return this.actor.getRelativeBounds(); 127 127 - } else { 128 128 - return this.actor.getRelativeBounds(); 129 129 - } 189 189 + public captureOldTransform() { 190 190 + // Capture old values before integration step updates them 191 191 + this.oldVel.setTo(this.vel.x, this.vel.y); 192 192 + this.oldPos.setTo(this.pos.x, this.pos.y); 193 193 + this.oldAcc.setTo(this.acc.x, this.acc.y); 194 194 + this.oldScale.setTo(this.scale.x, this.scale.y); 195 195 + this.oldRotation = this.rotation; 130 196 } 131 197 132 198 /** 133 133 - * Updates the collision area geometry and internal caches 199 199 + * Perform euler integration at the specified time step 134 200 */ 135 135 - public update() { 136 136 - if (this.collisionArea) { 137 137 - // Update the geometry if needed 138 138 - if (this.actor && this.actor.isGeometryDirty && this.collisionArea instanceof PolygonArea) { 139 139 - this.collisionArea.points = this.actor.getRelativeGeometry(); 140 140 - } 201 201 + public integrate(delta: number) { 202 202 + // Update placements based on linear algebra 203 203 + const seconds = delta / 1000; 204 204 + 205 205 + const totalAcc = this.acc.clone(); 206 206 + // Only active vanilla actors are affected by global acceleration 207 207 + if (this.collider.type === CollisionType.Active) { 208 208 + totalAcc.addEqual(Physics.acc); 209 209 + } 210 210 + 211 211 + this.vel.addEqual(totalAcc.scale(seconds)); 212 212 + this.pos.addEqual(this.vel.scale(seconds)).addEqual(totalAcc.scale(0.5 * seconds * seconds)); 141 213 142 142 - this.collisionArea.recalc(); 214 214 + this.rx += this.torque * (1.0 / this.collider.inertia) * seconds; 215 215 + this.rotation += this.rx * seconds; 216 216 + 217 217 + this.scale.x += (this.sx * delta) / 1000; 218 218 + this.scale.y += (this.sy * delta) / 1000; 219 219 + 220 220 + if (!this.scale.equals(this.oldScale)) { 221 221 + // change in scale effects the geometry 222 222 + this._geometryDirty = true; 143 223 } 224 224 + 225 225 + // Update colliders 226 226 + this.collider.update(); 227 227 + this._geometryDirty = false; 144 228 } 145 229 146 230 /** 147 147 - * Sets up a box collision area based on the current bounds of the associated actor of this physics body. 231 231 + * Sets up a box geometry based on the current bounds of the associated actor of this physics body. 148 232 * 149 233 * By default, the box is center is at (0, 0) which means it is centered around the actors anchor. 150 234 */ 151 151 - public useBoxCollision(center: Vector = Vector.Zero) { 152 152 - this.collisionArea = new PolygonArea({ 153 153 - body: this, 154 154 - points: this.actor.getRelativeGeometry(), 155 155 - pos: center // position relative to actor 156 156 - }); 235 235 + public useBoxCollider(width: number, height: number, anchor: Vector = Vector.Half, center: Vector = Vector.Zero): Collider { 236 236 + this.collider.shape = Shape.Box(width, height, anchor, center); 237 237 + return this.collider; 238 238 + } 157 239 158 158 - // in case of a nan moi, coalesce to a safe default 159 159 - this.moi = this.collisionArea.getMomentOfInertia() || this.moi; 240 240 + /** 241 241 + * @obsolete Body.useBoxCollision will be removed in v0.24.0 use [[Body.useBoxCollider]] 242 242 + */ 243 243 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Body.useBoxCollider' }) 244 244 + public useBoxCollision(center: Vector = Vector.Zero) { 245 245 + this.useBoxCollider(this.actor.width, this.actor.height, this.actor.anchor, center); 160 246 } 161 247 162 248 /** 163 163 - * Sets up a polygon collision area based on a list of of points relative to the anchor of the associated actor of this physics body. 249 249 + * Sets up a [[ConvexPolygon|convex polygon]] collision geometry based on a list of of points relative 250 250 + * to the anchor of the associated actor 251 251 + * of this physics body. 164 252 * 165 253 * Only [convex polygon](https://en.wikipedia.org/wiki/Convex_polygon) definitions are supported. 166 254 * 167 255 * By default, the box is center is at (0, 0) which means it is centered around the actors anchor. 168 256 */ 257 257 + public usePolygonCollider(points: Vector[], center: Vector = Vector.Zero): Collider { 258 258 + this.collider.shape = Shape.Polygon(points, false, center); 259 259 + return this.collider; 260 260 + } 261 261 + 262 262 + /** 263 263 + * @obsolete Body.usePolygonCollision will be removed in v0.24.0 use [[Body.usePolygonCollider]] 264 264 + */ 265 265 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Body.usePolygonCollider' }) 169 266 public usePolygonCollision(points: Vector[], center: Vector = Vector.Zero) { 170 170 - this.collisionArea = new PolygonArea({ 171 171 - body: this, 172 172 - points: points, 173 173 - pos: center // position relative to actor 174 174 - }); 175 175 - 176 176 - // in case of a nan moi, collesce to a safe default 177 177 - this.moi = this.collisionArea.getMomentOfInertia() || this.moi; 267 267 + this.usePolygonCollider(points, center); 178 268 } 179 269 180 270 /** 181 181 - * Sets up a [[CircleArea|circle collision area]] with a specified radius in pixels. 271 271 + * Sets up a [[Circle|circle collision geometry]] with a specified radius in pixels. 182 272 * 183 273 * By default, the box is center is at (0, 0) which means it is centered around the actors anchor. 184 274 */ 275 275 + public useCircleCollider(radius: number, center: Vector = Vector.Zero): Collider { 276 276 + this.collider.shape = Shape.Circle(radius, center); 277 277 + return this.collider; 278 278 + } 279 279 + 280 280 + /** 281 281 + * @obsolete Body.useCircleCollision will be removed in v0.24.0, use [[Body.useCircleCollider]] 282 282 + */ 283 283 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Body.useCircleCollider' }) 185 284 public useCircleCollision(radius?: number, center: Vector = Vector.Zero) { 186 186 - if (!radius) { 187 187 - radius = this.actor.getWidth() / 2; 188 188 - } 189 189 - this.collisionArea = new CircleArea({ 190 190 - body: this, 191 191 - radius: radius, 192 192 - pos: center 193 193 - }); 194 194 - this.moi = this.collisionArea.getMomentOfInertia() || this.moi; 285 285 + this.useCircleCollider(radius, center); 195 286 } 196 287 197 288 /** 198 198 - * Sets up an [[EdgeArea|edge collision]] with a start point and an end point relative to the anchor of the associated actor 289 289 + * Sets up an [[Edge|edge collision geometry]] with a start point and an end point relative to the anchor of the associated actor 199 290 * of this physics body. 200 291 * 201 292 * By default, the box is center is at (0, 0) which means it is centered around the actors anchor. 202 293 */ 203 203 - public useEdgeCollision(begin: Vector, end: Vector) { 204 204 - this.collisionArea = new EdgeArea({ 205 205 - begin: begin, 206 206 - end: end, 207 207 - body: this 208 208 - }); 209 209 - 210 210 - this.moi = this.collisionArea.getMomentOfInertia() || this.moi; 211 211 - } 212 212 - 213 213 - /* istanbul ignore next */ 214 214 - public debugDraw(ctx: CanvasRenderingContext2D) { 215 215 - // Draw motion vectors 216 216 - if (Physics.showMotionVectors) { 217 217 - DrawUtil.vector(ctx, Color.Yellow, this.pos, this.acc.add(Physics.acc)); 218 218 - DrawUtil.vector(ctx, Color.Red, this.pos, this.vel); 219 219 - DrawUtil.point(ctx, Color.Red, this.pos); 220 220 - } 221 221 - 222 222 - if (Physics.showBounds) { 223 223 - this.getBounds().debugDraw(ctx, Color.Yellow); 224 224 - } 225 225 - 226 226 - if (Physics.showArea) { 227 227 - this.collisionArea.debugDraw(ctx, Color.Green); 228 228 - } 294 294 + public useEdgeCollider(begin: Vector, end: Vector): Collider { 295 295 + this.collider.shape = Shape.Edge(begin, end); 296 296 + return this.collider; 229 297 } 230 298 231 299 /** 232 232 - * Returns a boolean indicating whether this body collided with 233 233 - * or was in stationary contact with 234 234 - * the body of the other [[Actor]] 300 300 + * @obsolete Body.useEdgeCollision will be removed in v0.24.0, use [[Body.useEdgeCollider]] 235 301 */ 236 236 - public touching(other: Actor): boolean { 237 237 - const pair = new Pair(this, other.body); 238 238 - pair.collide(); 302 302 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'Body.useEdgeCollider' }) 303 303 + public useEdgeCollision(begin: Vector, end: Vector) { 304 304 + this.useEdgeCollider(begin, end); 305 305 + } 239 306 240 240 - if (pair.collision) { 241 241 - return true; 242 242 - } 243 243 - 244 244 - return false; 307 307 + // TODO remove this, eventually events will stay local to the thing they are around 308 308 + private _wireColliderEventsToActor() { 309 309 + this.collider.clear(); 310 310 + this.collider.on('precollision', (evt: PreCollisionEvent<Collider>) => { 311 311 + if (this.actor) { 312 312 + this.actor.emit('precollision', new PreCollisionEvent(evt.target.body.actor, evt.other.body.actor, evt.side, evt.intersection)); 313 313 + } 314 314 + }); 315 315 + this.collider.on('postcollision', (evt: PostCollisionEvent<Collider>) => { 316 316 + if (this.actor) { 317 317 + this.actor.emit('postcollision', new PostCollisionEvent(evt.target.body.actor, evt.other.body.actor, evt.side, evt.intersection)); 318 318 + } 319 319 + }); 320 320 + this.collider.on('collisionstart', (evt: CollisionStartEvent<Collider>) => { 321 321 + if (this.actor) { 322 322 + this.actor.emit('collisionstart', new CollisionStartEvent(evt.target.body.actor, evt.other.body.actor, evt.pair)); 323 323 + } 324 324 + }); 325 325 + this.collider.on('collisionend', (evt: CollisionEndEvent<Collider>) => { 326 326 + if (this.actor) { 327 327 + this.actor.emit('collisionend', new CollisionEndEvent(evt.target.body.actor, evt.other.body.actor)); 328 328 + } 329 329 + }); 245 330 } 246 331 }

+209 -137

src/engine/Collision/BoundingBox.ts

Reviewed

··· 1 1 - import { PolygonArea } from './PolygonArea'; 1 1 + import { ConvexPolygon } from './ConvexPolygon'; 2 2 3 3 import { Actor } from '../Actor'; 4 4 import { Vector, Ray } from '../Algebra'; 5 5 import { Color } from '../Drawing/Color'; 6 6 - 7 7 - /** 8 8 - * Interface all collidable objects must implement 9 9 - */ 10 10 - export interface Collidable { 11 11 - /** 12 12 - * Test whether this bounding box collides with another one. 13 13 - * 14 14 - * @param collidable Other collidable to test 15 15 - * @returns Vector The intersection vector that can be used to resolve the collision. 16 16 - * If there is no collision, `null` is returned. 17 17 - */ 18 18 - collides(collidable: Collidable): Vector; 19 19 - /** 20 20 - * Tests wether a point is contained within the collidable 21 21 - * @param point The point to test 22 22 - */ 23 23 - contains(point: Vector): boolean; 24 24 - 25 25 - debugDraw(ctx: CanvasRenderingContext2D): void; 26 26 - } 6 6 + import { obsolete } from '../Util/Decorators'; 7 7 + import { Side } from './Side'; 27 8 28 9 /** 29 10 * Axis Aligned collision primitive for Excalibur. 30 11 */ 31 31 - export class BoundingBox implements Collidable { 12 12 + export class BoundingBox { 32 13 /** 33 14 * @param left x coordinate of the left edge 34 15 * @param top y coordinate of the top edge ··· 37 18 */ 38 19 constructor(public left: number = 0, public top: number = 0, public right: number = 0, public bottom: number = 0) {} 39 20 21 21 + /** 22 22 + * Given bounding box A & B, returns the side relative to A when intersection is performed. 23 23 + * @param intersection Intersection vector between 2 bounding boxes 24 24 + */ 25 25 + public static getSideFromIntersection(intersection: Vector): Side { 26 26 + if (!intersection) { 27 27 + return Side.None; 28 28 + } 29 29 + if (intersection) { 30 30 + if (Math.abs(intersection.x) > Math.abs(intersection.y)) { 31 31 + if (intersection.x < 0) { 32 32 + return Side.Right; 33 33 + } 34 34 + return Side.Left; 35 35 + } else { 36 36 + if (intersection.y < 0) { 37 37 + return Side.Bottom; 38 38 + } 39 39 + return Side.Top; 40 40 + } 41 41 + } 42 42 + return Side.None; 43 43 + } 44 44 + 40 45 public static fromPoints(points: Vector[]): BoundingBox { 41 46 let minX = Infinity; 42 47 let minY = Infinity; ··· 59 64 return new BoundingBox(minX, minY, maxX, maxY); 60 65 } 61 66 67 67 + public static fromDimension(width: number, height: number, anchor: Vector = Vector.Half, pos: Vector = Vector.Zero) { 68 68 + return new BoundingBox( 69 69 + -width * anchor.x + pos.x, 70 70 + -height * anchor.y + pos.y, 71 71 + width - width * anchor.x + pos.x, 72 72 + height - height * anchor.y + pos.y 73 73 + ); 74 74 + } 75 75 + 62 76 /** 63 77 * Returns the calculated width of the bounding box 64 78 */ 79 79 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'BoundingBox.width' }) 65 80 public getWidth() { 81 81 + return this.width; 82 82 + } 83 83 + 84 84 + /** 85 85 + * Returns the calculated width of the bounding box 86 86 + */ 87 87 + public get width() { 66 88 return this.right - this.left; 67 89 } 68 90 69 91 /** 70 92 * Returns the calculated height of the bounding box 71 93 */ 94 94 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'BoundingBox.height' }) 72 95 public getHeight() { 96 96 + return this.height; 97 97 + } 98 98 + 99 99 + /** 100 100 + * Returns the calculated height of the bounding box 101 101 + */ 102 102 + public get height() { 73 103 return this.bottom - this.top; 74 104 } 75 105 76 106 /** 107 107 + * Returns the center of the bounding box 108 108 + */ 109 109 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'BoundingBox.center' }) 110 110 + public getCenter(): Vector { 111 111 + return new Vector((this.left + this.right) / 2, (this.top + this.bottom) / 2); 112 112 + } 113 113 + 114 114 + /** 115 115 + * Returns the center of the bounding box 116 116 + */ 117 117 + public get center(): Vector { 118 118 + return new Vector((this.left + this.right) / 2, (this.top + this.bottom) / 2); 119 119 + } 120 120 + 121 121 + public translate(pos: Vector): BoundingBox { 122 122 + return new BoundingBox(this.left + pos.x, this.top + pos.y, this.right + pos.x, this.bottom + pos.y); 123 123 + } 124 124 + 125 125 + /** 77 126 * Rotates a bounding box by and angle and around a point, if no point is specified (0, 0) is used by default. The resulting bounding 78 127 * box is also axis-align. This is useful when a new axis-aligned bounding box is needed for rotated geometry. 79 128 */ ··· 82 131 return BoundingBox.fromPoints(points); 83 132 } 84 133 134 134 + public scale(scale: Vector, point: Vector = Vector.Zero): BoundingBox { 135 135 + const shifted = this.translate(point); 136 136 + return new BoundingBox(shifted.left * scale.x, shifted.top * scale.y, shifted.right * scale.x, shifted.bottom * scale.y); 137 137 + } 138 138 + 85 139 /** 86 140 * Returns the perimeter of the bounding box 87 141 */ 88 142 public getPerimeter(): number { 89 89 - const wx = this.getWidth(); 90 90 - const wy = this.getHeight(); 143 143 + const wx = this.width; 144 144 + const wy = this.height; 91 145 return 2 * (wx + wy); 92 146 } 93 147 ··· 103 157 /** 104 158 * Creates a Polygon collision area from the points of the bounding box 105 159 */ 106 106 - public toPolygon(actor?: Actor): PolygonArea { 107 107 - return new PolygonArea({ 160 160 + public toPolygon(actor?: Actor): ConvexPolygon { 161 161 + return new ConvexPolygon({ 108 162 body: actor ? actor.body : null, 109 163 points: this.getPoints(), 110 164 pos: Vector.Zero ··· 197 251 } 198 252 199 253 public get dimensions(): Vector { 200 200 - return new Vector(this.getWidth(), this.getHeight()); 254 254 + return new Vector(this.width, this.height); 201 255 } 202 256 203 257 /** 204 204 - * Test wether this bounding box collides with another returning, 258 258 + * Test wether this bounding box intersects with another returning 205 259 * the intersection vector that can be used to resolve the collision. If there 206 206 - * is no collision null is returned. 260 260 + * is no intersection null is returned. 207 261 * 208 208 - * @returns A Vector in the direction of the current BoundingBox 209 209 - * @param collidable Other collidable to test 262 262 + * @param other Other [[BoundingBox]] to test intersection with 263 263 + * @returns A Vector in the direction of the current BoundingBox, this <- other 210 264 */ 211 211 - public collides(collidable: Collidable): Vector { 212 212 - if (collidable instanceof BoundingBox) { 213 213 - const other: BoundingBox = <BoundingBox>collidable; 214 214 - const totalBoundingBox = this.combine(other); 265 265 + public intersect(other: BoundingBox): Vector { 266 266 + const totalBoundingBox = this.combine(other); 215 267 216 216 - // If the total bounding box is less than or equal the sum of the 2 bounds then there is collision 217 217 - if ( 218 218 - totalBoundingBox.getWidth() < other.getWidth() + this.getWidth() && 219 219 - totalBoundingBox.getHeight() < other.getHeight() + this.getHeight() && 220 220 - !totalBoundingBox.dimensions.equals(other.dimensions) && 221 221 - !totalBoundingBox.dimensions.equals(this.dimensions) 222 222 - ) { 223 223 - // collision 224 224 - let overlapX = 0; 225 225 - // right edge is between the other's left and right edge 268 268 + // If the total bounding box is less than or equal the sum of the 2 bounds then there is collision 269 269 + if ( 270 270 + totalBoundingBox.width < other.width + this.width && 271 271 + totalBoundingBox.height < other.height + this.height && 272 272 + !totalBoundingBox.dimensions.equals(other.dimensions) && 273 273 + !totalBoundingBox.dimensions.equals(this.dimensions) 274 274 + ) { 275 275 + // collision 276 276 + let overlapX = 0; 277 277 + // right edge is between the other's left and right edge 278 278 + /** 279 279 + * +-this-+ 280 280 + * | | 281 281 + * | +-other-+ 282 282 + * +----|-+ | 283 283 + * | | 284 284 + * +-------+ 285 285 + * <--- 286 286 + * ^ overlap 287 287 + */ 288 288 + if (this.right >= other.left && this.right <= other.right) { 289 289 + overlapX = other.left - this.right; 290 290 + // right edge is past the other's right edge 226 291 /** 227 227 - * +-this-+ 228 228 - * | | 229 229 - * | +-other-+ 230 230 - * +----|-+ | 231 231 - * | | 232 232 - * +-------+ 233 233 - * <--- 292 292 + * +-other-+ 293 293 + * | | 294 294 + * | +-this-+ 295 295 + * +----|--+ | 296 296 + * | | 297 297 + * +------+ 298 298 + * ---> 234 299 * ^ overlap 235 300 */ 236 236 - if (this.right >= other.left && this.right <= other.right) { 237 237 - overlapX = other.left - this.right; 238 238 - // right edge is past the other's right edge 239 239 - /** 240 240 - * +-other-+ 241 241 - * | | 242 242 - * | +-this-+ 243 243 - * +----|--+ | 244 244 - * | | 245 245 - * +------+ 246 246 - * ---> 247 247 - * ^ overlap 248 248 - */ 249 249 - } else { 250 250 - overlapX = other.right - this.left; 251 251 - } 301 301 + } else { 302 302 + overlapX = other.right - this.left; 303 303 + } 252 304 253 253 - let overlapY = 0; 254 254 - // top edge is between the other's top and bottom edge 305 305 + let overlapY = 0; 306 306 + // top edge is between the other's top and bottom edge 307 307 + /** 308 308 + * +-other-+ 309 309 + * | | 310 310 + * | +-this-+ | <- overlap 311 311 + * +----|--+ | | 312 312 + * | | \ / 313 313 + * +------+ ' 314 314 + */ 315 315 + if (this.top <= other.bottom && this.top >= other.top) { 316 316 + overlapY = other.bottom - this.top; 317 317 + // top edge is above the other top edge 255 318 /** 256 256 - * +-other-+ 257 257 - * | | 258 258 - * | +-this-+ | <- overlap 259 259 - * +----|--+ | | 260 260 - * | | \ / 261 261 - * +------+ ' 319 319 + * +-this-+ . 320 320 + * | | / \ 321 321 + * | +-other-+ | <- overlap 322 322 + * +----|-+ | | 323 323 + * | | 324 324 + * +-------+ 262 325 */ 263 263 - if (this.top <= other.bottom && this.top >= other.top) { 264 264 - overlapY = other.bottom - this.top; 265 265 - // top edge is above the other top edge 266 266 - /** 267 267 - * +-this-+ . 268 268 - * | | / \ 269 269 - * | +-other-+ | <- overlap 270 270 - * +----|-+ | | 271 271 - * | | 272 272 - * +-------+ 273 273 - */ 274 274 - } else { 275 275 - overlapY = other.top - this.bottom; 276 276 - } 326 326 + } else { 327 327 + overlapY = other.top - this.bottom; 328 328 + } 277 329 278 278 - if (Math.abs(overlapX) < Math.abs(overlapY)) { 279 279 - return new Vector(overlapX, 0); 330 330 + if (Math.abs(overlapX) < Math.abs(overlapY)) { 331 331 + return new Vector(overlapX, 0); 332 332 + } else { 333 333 + return new Vector(0, overlapY); 334 334 + } 335 335 + // Case of total containment of one bounding box by another 336 336 + } else if (totalBoundingBox.dimensions.equals(other.dimensions) || totalBoundingBox.dimensions.equals(this.dimensions)) { 337 337 + let overlapX = 0; 338 338 + // this is wider than the other 339 339 + if (this.width - other.width >= 0) { 340 340 + // This right edge is closest to the others right edge 341 341 + if (this.right - other.right <= other.left - this.left) { 342 342 + overlapX = other.left - this.right; 343 343 + // This left edge is closest to the others left edge 280 344 } else { 281 281 - return new Vector(0, overlapY); 345 345 + overlapX = other.right - this.left; 282 346 } 283 283 - // Case of total containment of one bounding box by another 284 284 - } else if (totalBoundingBox.dimensions.equals(other.dimensions) || totalBoundingBox.dimensions.equals(this.dimensions)) { 285 285 - let overlapX = 0; 286 286 - // this is wider than the other 287 287 - if (this.getWidth() - other.getWidth() >= 0) { 288 288 - // This right edge is closest to the others right edge 289 289 - if (this.right - other.right <= other.left - this.left) { 290 290 - overlapX = other.left - this.right; 291 291 - // This left edge is closest to the others left edge 292 292 - } else { 293 293 - overlapX = other.right - this.left; 294 294 - } 295 295 - // other is wider than this 347 347 + // other is wider than this 348 348 + } else { 349 349 + // This right edge is closest to the others right edge 350 350 + if (other.right - this.right <= this.left - other.left) { 351 351 + overlapX = this.left - other.right; 352 352 + // This left edge is closest to the others left edge 296 353 } else { 297 297 - // This right edge is closest to the others right edge 298 298 - if (other.right - this.right <= this.left - other.left) { 299 299 - overlapX = this.left - other.right; 300 300 - // This left edge is closest to the others left edge 301 301 - } else { 302 302 - overlapX = this.right - other.left; 303 303 - } 354 354 + overlapX = this.right - other.left; 304 355 } 356 356 + } 305 357 306 306 - let overlapY = 0; 307 307 - // this is taller than other 308 308 - if (this.getHeight() - other.getHeight() >= 0) { 309 309 - // The bottom edge is closest to the others bottom edge 310 310 - if (this.bottom - other.bottom <= other.top - this.top) { 311 311 - overlapY = other.top - this.bottom; 312 312 - } else { 313 313 - overlapY = other.bottom - this.top; 314 314 - } 315 315 - // other is taller than this 358 358 + let overlapY = 0; 359 359 + // this is taller than other 360 360 + if (this.height - other.height >= 0) { 361 361 + // The bottom edge is closest to the others bottom edge 362 362 + if (this.bottom - other.bottom <= other.top - this.top) { 363 363 + overlapY = other.top - this.bottom; 316 364 } else { 317 317 - // The bottom edge is closest to the others bottom edge 318 318 - if (other.bottom - this.bottom <= this.top - other.top) { 319 319 - overlapY = this.top - other.bottom; 320 320 - } else { 321 321 - overlapY = this.bottom - other.top; 322 322 - } 365 365 + overlapY = other.bottom - this.top; 323 366 } 324 324 - 325 325 - if (Math.abs(overlapX) < Math.abs(overlapY)) { 326 326 - return new Vector(overlapX, 0); 367 367 + // other is taller than this 368 368 + } else { 369 369 + // The bottom edge is closest to the others bottom edge 370 370 + if (other.bottom - this.bottom <= this.top - other.top) { 371 371 + overlapY = this.top - other.bottom; 327 372 } else { 328 328 - return new Vector(0, overlapY); 373 373 + overlapY = this.bottom - other.top; 329 374 } 375 375 + } 376 376 + 377 377 + if (Math.abs(overlapX) < Math.abs(overlapY)) { 378 378 + return new Vector(overlapX, 0); 330 379 } else { 331 331 - return null; 380 380 + return new Vector(0, overlapY); 332 381 } 382 382 + } else { 383 383 + return null; 333 384 } 385 385 + } 334 386 335 335 - return null; 387 387 + /** 388 388 + * Test whether the bounding box has intersected with another bounding box, returns the side of the current bb that intersected. 389 389 + * @param bb The other actor to test 390 390 + */ 391 391 + public intersectWithSide(bb: BoundingBox): Side { 392 392 + const intersect = this.intersect(bb); 393 393 + return BoundingBox.getSideFromIntersection(intersect); 394 394 + } 395 395 + 396 396 + /** 397 397 + * Test wether this bounding box collides with another returning, 398 398 + * the intersection vector that can be used to resolve the collision. If there 399 399 + * is no collision null is returned. 400 400 + * 401 401 + * @returns A Vector in the direction of the current BoundingBox 402 402 + * @param boundingBox Other collidable to test 403 403 + * @obsolete BoundingBox.collides will be removed in v0.24.0, use BoundingBox.intersect 404 404 + */ 405 405 + @obsolete({ message: 'BoundingBox.collides will be removed in v0.24.0', alternateMethod: 'BoundingBox.intersect' }) 406 406 + public collides(boundingBox: BoundingBox): Vector { 407 407 + return this.intersect(boundingBox); 336 408 } 337 409 338 410 /* istanbul ignore next */ 339 411 public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Yellow) { 340 412 ctx.strokeStyle = color.toString(); 341 341 - ctx.strokeRect(this.left, this.top, this.getWidth(), this.getHeight()); 413 413 + ctx.strokeRect(this.left, this.top, this.width, this.height); 342 414 } 343 415 }

+304

src/engine/Collision/Circle.ts

Reviewed

··· 1 1 + import { BoundingBox } from './BoundingBox'; 2 2 + import { CollisionJumpTable } from './CollisionJumpTable'; 3 3 + import { CollisionContact } from './CollisionContact'; 4 4 + import { CollisionShape } from './CollisionShape'; 5 5 + import { ConvexPolygon } from './ConvexPolygon'; 6 6 + import { Edge } from './Edge'; 7 7 + 8 8 + import { Vector, Ray, Projection } from '../Algebra'; 9 9 + import { Physics } from '../Physics'; 10 10 + import { Color } from '../Drawing/Color'; 11 11 + import { Collider } from './Collider'; 12 12 + 13 13 + // @obsolete Remove in v0.24.0 14 14 + import { Body } from './Body'; 15 15 + // =========================== 16 16 + 17 17 + export interface CircleOptions { 18 18 + /** 19 19 + * Optional position to shift the circle relative to the collider, by default (0, 0). 20 20 + */ 21 21 + pos?: Vector; 22 22 + /** 23 23 + * Required radius of the circle 24 24 + */ 25 25 + radius: number; 26 26 + /** 27 27 + * Optional collider to associate with this shape 28 28 + */ 29 29 + collider?: Collider; 30 30 + 31 31 + // @obsolete Will be removed in v0.24.0 please use [[collider]] to set and retrieve body information 32 32 + body?: Body; 33 33 + } 34 34 + 35 35 + /** 36 36 + * This is a circle collision shape for the excalibur rigid body physics simulation 37 37 + * 38 38 + * Example: 39 39 + * [[include:CircleShape.md]] 40 40 + */ 41 41 + export class Circle implements CollisionShape { 42 42 + /** 43 43 + * Position of the circle relative to the collider, by default (0, 0) meaning the shape is positioned on top of the collider. 44 44 + */ 45 45 + public pos: Vector = Vector.Zero; 46 46 + 47 47 + public get worldPos(): Vector { 48 48 + if (this.collider && this.collider.body) { 49 49 + return this.collider.body.pos.add(this.pos); 50 50 + } 51 51 + return this.pos; 52 52 + } 53 53 + 54 54 + /** 55 55 + * This is the radius of the circle 56 56 + */ 57 57 + public radius: number; 58 58 + 59 59 + /** 60 60 + * Reference to the actor associated with this collision shape 61 61 + * @obsolete Will be removed in v0.24.0 please use [[collider]] to retrieve body information 62 62 + */ 63 63 + public body: Body; 64 64 + 65 65 + /** 66 66 + * The collider associated for this shape, if any. 67 67 + */ 68 68 + public collider?: Collider; 69 69 + 70 70 + constructor(options: CircleOptions) { 71 71 + this.pos = options.pos || Vector.Zero; 72 72 + this.radius = options.radius || 0; 73 73 + this.collider = options.collider || null; 74 74 + 75 75 + // @obsolete Remove next release in v0.24.0, code exists for backwards compat 76 76 + if (options.body) { 77 77 + this.collider = options.body.collider; 78 78 + this.body = this.collider.body; 79 79 + } 80 80 + // ================================== 81 81 + } 82 82 + 83 83 + /** 84 84 + * Returns a clone of this shape, not associated with any collider 85 85 + */ 86 86 + public clone(): Circle { 87 87 + return new Circle({ 88 88 + pos: this.pos.clone(), 89 89 + radius: this.radius, 90 90 + collider: null, 91 91 + body: null 92 92 + }); 93 93 + } 94 94 + 95 95 + /** 96 96 + * Get the center of the collision shape in world coordinates 97 97 + */ 98 98 + public get center(): Vector { 99 99 + if (this.collider && this.collider.body) { 100 100 + return this.pos.add(this.collider.body.pos); 101 101 + } 102 102 + return this.pos; 103 103 + } 104 104 + 105 105 + /** 106 106 + * Tests if a point is contained in this collision shape 107 107 + */ 108 108 + public contains(point: Vector): boolean { 109 109 + let pos = this.pos; 110 110 + if (this.collider && this.collider.body) { 111 111 + pos = this.collider.body.pos; 112 112 + } 113 113 + const distance = pos.distance(point); 114 114 + if (distance <= this.radius) { 115 115 + return true; 116 116 + } 117 117 + return false; 118 118 + } 119 119 + 120 120 + /** 121 121 + * Casts a ray at the Circl shape and returns the nearest point of collision 122 122 + * @param ray 123 123 + */ 124 124 + public rayCast(ray: Ray, max: number = Infinity): Vector { 125 125 + //https://en.wikipedia.org/wiki/Line%E2%80%93sphere_intersection 126 126 + const c = this.center; 127 127 + const dir = ray.dir; 128 128 + const orig = ray.pos; 129 129 + 130 130 + const discriminant = Math.sqrt(Math.pow(dir.dot(orig.sub(c)), 2) - Math.pow(orig.sub(c).distance(), 2) + Math.pow(this.radius, 2)); 131 131 + 132 132 + if (discriminant < 0) { 133 133 + // no intersection 134 134 + return null; 135 135 + } else { 136 136 + let toi = 0; 137 137 + if (discriminant === 0) { 138 138 + toi = -dir.dot(orig.sub(c)); 139 139 + if (toi > 0 && toi < max) { 140 140 + return ray.getPoint(toi); 141 141 + } 142 142 + return null; 143 143 + } else { 144 144 + const toi1 = -dir.dot(orig.sub(c)) + discriminant; 145 145 + const toi2 = -dir.dot(orig.sub(c)) - discriminant; 146 146 + 147 147 + const mintoi = Math.min(toi1, toi2); 148 148 + if (mintoi <= max) { 149 149 + return ray.getPoint(mintoi); 150 150 + } 151 151 + return null; 152 152 + } 153 153 + } 154 154 + } 155 155 + 156 156 + /** 157 157 + * @inheritdoc 158 158 + */ 159 159 + public collide(shape: CollisionShape): CollisionContact { 160 160 + if (shape instanceof Circle) { 161 161 + return CollisionJumpTable.CollideCircleCircle(this, shape); 162 162 + } else if (shape instanceof ConvexPolygon) { 163 163 + return CollisionJumpTable.CollideCirclePolygon(this, shape); 164 164 + } else if (shape instanceof Edge) { 165 165 + return CollisionJumpTable.CollideCircleEdge(this, shape); 166 166 + } else { 167 167 + throw new Error(`Circle could not collide with unknown CollisionShape ${typeof shape}`); 168 168 + } 169 169 + } 170 170 + 171 171 + /** 172 172 + * Find the point on the shape furthest in the direction specified 173 173 + */ 174 174 + public getFurthestPoint(direction: Vector): Vector { 175 175 + return this.center.add(direction.normalize().scale(this.radius)); 176 176 + } 177 177 + 178 178 + /** 179 179 + * Get the axis aligned bounding box for the circle shape in world coordinates 180 180 + */ 181 181 + public get bounds(): BoundingBox { 182 182 + let bodyPos = Vector.Zero; 183 183 + if (this.collider && this.collider.body) { 184 184 + bodyPos = this.collider.body.pos; 185 185 + } 186 186 + return new BoundingBox( 187 187 + this.pos.x + bodyPos.x - this.radius, 188 188 + this.pos.y + bodyPos.y - this.radius, 189 189 + this.pos.x + bodyPos.x + this.radius, 190 190 + this.pos.y + bodyPos.y + this.radius 191 191 + ); 192 192 + } 193 193 + 194 194 + /** 195 195 + * Get the axis aligned bounding box for the circle shape in local coordinates 196 196 + */ 197 197 + public get localBounds(): BoundingBox { 198 198 + return new BoundingBox(this.pos.x - this.radius, this.pos.y - this.radius, this.pos.x + this.radius, this.pos.y + this.radius); 199 199 + } 200 200 + 201 201 + /** 202 202 + * Get axis not implemented on circles, since there are infinite axis in a circle 203 203 + */ 204 204 + public get axes(): Vector[] { 205 205 + return null; 206 206 + } 207 207 + 208 208 + /** 209 209 + * Returns the moment of inertia of a circle given it's mass 210 210 + * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 211 211 + */ 212 212 + public get inertia(): number { 213 213 + const mass = this.collider ? this.collider.mass : Physics.defaultMass; 214 214 + return (mass * this.radius * this.radius) / 2; 215 215 + } 216 216 + 217 217 + /** 218 218 + * Tests the separating axis theorem for circles against polygons 219 219 + */ 220 220 + public testSeparatingAxisTheorem(polygon: ConvexPolygon): Vector { 221 221 + const axes = polygon.axes; 222 222 + const pc = polygon.center; 223 223 + // Special SAT with circles 224 224 + const closestPointOnPoly = polygon.getFurthestPoint(this.pos.sub(pc)); 225 225 + axes.push(this.pos.sub(closestPointOnPoly).normalize()); 226 226 + 227 227 + let minOverlap = Number.MAX_VALUE; 228 228 + let minAxis = null; 229 229 + let minIndex = -1; 230 230 + for (let i = 0; i < axes.length; i++) { 231 231 + const proj1 = polygon.project(axes[i]); 232 232 + const proj2 = this.project(axes[i]); 233 233 + const overlap = proj1.getOverlap(proj2); 234 234 + if (overlap <= 0) { 235 235 + return null; 236 236 + } else { 237 237 + if (overlap < minOverlap) { 238 238 + minOverlap = overlap; 239 239 + minAxis = axes[i]; 240 240 + minIndex = i; 241 241 + } 242 242 + } 243 243 + } 244 244 + if (minIndex < 0) { 245 245 + return null; 246 246 + } 247 247 + return minAxis.normalize().scale(minOverlap); 248 248 + } 249 249 + 250 250 + /* istanbul ignore next */ 251 251 + public recalc(): void { 252 252 + // circles don't cache 253 253 + } 254 254 + 255 255 + /** 256 256 + * Project the circle along a specified axis 257 257 + */ 258 258 + public project(axis: Vector): Projection { 259 259 + const scalars = []; 260 260 + const point = this.center; 261 261 + const dotProduct = point.dot(axis); 262 262 + scalars.push(dotProduct); 263 263 + scalars.push(dotProduct + this.radius); 264 264 + scalars.push(dotProduct - this.radius); 265 265 + return new Projection(Math.min.apply(Math, scalars), Math.max.apply(Math, scalars)); 266 266 + } 267 267 + 268 268 + public draw(ctx: CanvasRenderingContext2D, color: Color = Color.Green, pos: Vector = Vector.Zero) { 269 269 + const newPos = pos.add(this.pos); 270 270 + ctx.beginPath(); 271 271 + ctx.fillStyle = color.toString(); 272 272 + ctx.arc(newPos.x, newPos.y, this.radius, 0, Math.PI * 2); 273 273 + ctx.closePath(); 274 274 + ctx.fill(); 275 275 + } 276 276 + 277 277 + /* istanbul ignore next */ 278 278 + public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Green) { 279 279 + const body = this.collider.body; 280 280 + const pos = body ? body.pos.add(this.pos) : this.pos; 281 281 + const rotation = body ? body.rotation : 0; 282 282 + 283 283 + ctx.beginPath(); 284 284 + ctx.strokeStyle = color.toString(); 285 285 + ctx.arc(pos.x, pos.y, this.radius, 0, Math.PI * 2); 286 286 + ctx.closePath(); 287 287 + ctx.stroke(); 288 288 + ctx.beginPath(); 289 289 + ctx.moveTo(pos.x, pos.y); 290 290 + ctx.lineTo(Math.cos(rotation) * this.radius + pos.x, Math.sin(rotation) * this.radius + pos.y); 291 291 + ctx.closePath(); 292 292 + ctx.stroke(); 293 293 + } 294 294 + } 295 295 + 296 296 + /** 297 297 + * @obsolete Use [[CircleOptions]], CircleAreaOptions will be removed in v0.24.0 298 298 + */ 299 299 + export interface CircleAreaOptions extends CircleOptions {} 300 300 + 301 301 + /** 302 302 + * @obsolete Use [[Circle]], CircleArea will be removed in v0.24.0 303 303 + */ 304 304 + export class CircleArea extends Circle {}

-216

src/engine/Collision/CircleArea.ts

Reviewed

··· 1 1 - import { Body } from './Body'; 2 2 - import { BoundingBox } from './BoundingBox'; 3 3 - import { CollisionArea } from './CollisionArea'; 4 4 - import { PolygonArea } from './PolygonArea'; 5 5 - import { EdgeArea } from './EdgeArea'; 6 6 - import { CollisionJumpTable } from './CollisionJumpTable'; 7 7 - import { CollisionContact } from './CollisionContact'; 8 8 - 9 9 - import { Vector, Ray, Projection } from '../Algebra'; 10 10 - import { Physics } from '../Physics'; 11 11 - import { Color } from '../Drawing/Color'; 12 12 - 13 13 - export interface CircleAreaOptions { 14 14 - pos?: Vector; 15 15 - radius?: number; 16 16 - body?: Body; 17 17 - } 18 18 - 19 19 - /** 20 20 - * This is a circle collision area for the excalibur rigid body physics simulation 21 21 - */ 22 22 - export class CircleArea implements CollisionArea { 23 23 - /** 24 24 - * This is the center position of the circle, relative to the body position 25 25 - */ 26 26 - public pos: Vector = Vector.Zero; 27 27 - /** 28 28 - * This is the radius of the circle 29 29 - */ 30 30 - public radius: number; 31 31 - /** 32 32 - * The actor associated with this collision area 33 33 - */ 34 34 - public body: Body; 35 35 - 36 36 - constructor(options: CircleAreaOptions) { 37 37 - this.pos = options.pos || Vector.Zero; 38 38 - this.radius = options.radius || 0; 39 39 - this.body = options.body || null; 40 40 - } 41 41 - 42 42 - /** 43 43 - * Get the center of the collision area in world coordinates 44 44 - */ 45 45 - public getCenter(): Vector { 46 46 - if (this.body) { 47 47 - return this.pos.add(this.body.pos); 48 48 - } 49 49 - return this.pos; 50 50 - } 51 51 - 52 52 - /** 53 53 - * Tests if a point is contained in this collision area 54 54 - */ 55 55 - public contains(point: Vector): boolean { 56 56 - const distance = this.body.pos.distance(point); 57 57 - if (distance <= this.radius) { 58 58 - return true; 59 59 - } 60 60 - return false; 61 61 - } 62 62 - 63 63 - /** 64 64 - * Casts a ray at the CircleArea and returns the nearest point of collision 65 65 - * @param ray 66 66 - */ 67 67 - public rayCast(ray: Ray, max: number = Infinity): Vector { 68 68 - //https://en.wikipedia.org/wiki/Line%E2%80%93sphere_intersection 69 69 - const c = this.getCenter(); 70 70 - const dir = ray.dir; 71 71 - const orig = ray.pos; 72 72 - 73 73 - const discriminant = Math.sqrt(Math.pow(dir.dot(orig.sub(c)), 2) - Math.pow(orig.sub(c).distance(), 2) + Math.pow(this.radius, 2)); 74 74 - 75 75 - if (discriminant < 0) { 76 76 - // no intersection 77 77 - return null; 78 78 - } else { 79 79 - let toi = 0; 80 80 - if (discriminant === 0) { 81 81 - toi = -dir.dot(orig.sub(c)); 82 82 - if (toi > 0 && toi < max) { 83 83 - return ray.getPoint(toi); 84 84 - } 85 85 - return null; 86 86 - } else { 87 87 - const toi1 = -dir.dot(orig.sub(c)) + discriminant; 88 88 - const toi2 = -dir.dot(orig.sub(c)) - discriminant; 89 89 - 90 90 - const mintoi = Math.min(toi1, toi2); 91 91 - if (mintoi <= max) { 92 92 - return ray.getPoint(mintoi); 93 93 - } 94 94 - return null; 95 95 - } 96 96 - } 97 97 - } 98 98 - 99 99 - /** 100 100 - * @inheritdoc 101 101 - */ 102 102 - public collide(area: CollisionArea): CollisionContact { 103 103 - if (area instanceof CircleArea) { 104 104 - return CollisionJumpTable.CollideCircleCircle(this, area); 105 105 - } else if (area instanceof PolygonArea) { 106 106 - return CollisionJumpTable.CollideCirclePolygon(this, area); 107 107 - } else if (area instanceof EdgeArea) { 108 108 - return CollisionJumpTable.CollideCircleEdge(this, area); 109 109 - } else { 110 110 - throw new Error(`Circle could not collide with unknown ICollisionArea ${typeof area}`); 111 111 - } 112 112 - } 113 113 - 114 114 - /** 115 115 - * Find the point on the shape furthest in the direction specified 116 116 - */ 117 117 - public getFurthestPoint(direction: Vector): Vector { 118 118 - return this.getCenter().add(direction.normalize().scale(this.radius)); 119 119 - } 120 120 - 121 121 - /** 122 122 - * Get the axis aligned bounding box for the circle area 123 123 - */ 124 124 - public getBounds(): BoundingBox { 125 125 - return new BoundingBox( 126 126 - this.pos.x + this.body.pos.x - this.radius, 127 127 - this.pos.y + this.body.pos.y - this.radius, 128 128 - this.pos.x + this.body.pos.x + this.radius, 129 129 - this.pos.y + this.body.pos.y + this.radius 130 130 - ); 131 131 - } 132 132 - 133 133 - /** 134 134 - * Get axis not implemented on circles, since there are infinite axis in a circle 135 135 - */ 136 136 - public getAxes(): Vector[] { 137 137 - return null; 138 138 - } 139 139 - 140 140 - /** 141 141 - * Returns the moment of inertia of a circle given it's mass 142 142 - * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 143 143 - */ 144 144 - public getMomentOfInertia(): number { 145 145 - const mass = this.body ? this.body.mass : Physics.defaultMass; 146 146 - return (mass * this.radius * this.radius) / 2; 147 147 - } 148 148 - 149 149 - /** 150 150 - * Tests the separating axis theorem for circles against polygons 151 151 - */ 152 152 - public testSeparatingAxisTheorem(polygon: PolygonArea): Vector { 153 153 - const axes = polygon.getAxes(); 154 154 - const pc = polygon.getCenter(); 155 155 - // Special SAT with circles 156 156 - const closestPointOnPoly = polygon.getFurthestPoint(this.pos.sub(pc)); 157 157 - axes.push(this.pos.sub(closestPointOnPoly).normalize()); 158 158 - 159 159 - let minOverlap = Number.MAX_VALUE; 160 160 - let minAxis = null; 161 161 - let minIndex = -1; 162 162 - for (let i = 0; i < axes.length; i++) { 163 163 - const proj1 = polygon.project(axes[i]); 164 164 - const proj2 = this.project(axes[i]); 165 165 - const overlap = proj1.getOverlap(proj2); 166 166 - if (overlap <= 0) { 167 167 - return null; 168 168 - } else { 169 169 - if (overlap < minOverlap) { 170 170 - minOverlap = overlap; 171 171 - minAxis = axes[i]; 172 172 - minIndex = i; 173 173 - } 174 174 - } 175 175 - } 176 176 - if (minIndex < 0) { 177 177 - return null; 178 178 - } 179 179 - return minAxis.normalize().scale(minOverlap); 180 180 - } 181 181 - 182 182 - /* istanbul ignore next */ 183 183 - public recalc(): void { 184 184 - // circles don't cache 185 185 - } 186 186 - 187 187 - /** 188 188 - * Project the circle along a specified axis 189 189 - */ 190 190 - public project(axis: Vector): Projection { 191 191 - const scalars = []; 192 192 - const point = this.getCenter(); 193 193 - const dotProduct = point.dot(axis); 194 194 - scalars.push(dotProduct); 195 195 - scalars.push(dotProduct + this.radius); 196 196 - scalars.push(dotProduct - this.radius); 197 197 - return new Projection(Math.min.apply(Math, scalars), Math.max.apply(Math, scalars)); 198 198 - } 199 199 - 200 200 - /* istanbul ignore next */ 201 201 - public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Green) { 202 202 - const pos = this.body ? this.body.pos.add(this.pos) : this.pos; 203 203 - const rotation = this.body ? this.body.rotation : 0; 204 204 - 205 205 - ctx.beginPath(); 206 206 - ctx.strokeStyle = color.toString(); 207 207 - ctx.arc(pos.x, pos.y, this.radius, 0, Math.PI * 2); 208 208 - ctx.closePath(); 209 209 - ctx.stroke(); 210 210 - ctx.beginPath(); 211 211 - ctx.moveTo(pos.x, pos.y); 212 212 - ctx.lineTo(Math.cos(rotation) * this.radius + pos.x, Math.sin(rotation) * this.radius + pos.y); 213 213 - ctx.closePath(); 214 214 - ctx.stroke(); 215 215 - } 216 216 - }

+247

src/engine/Collision/Collider.ts

Reviewed

··· 1 1 + import { Color } from '../Drawing/Color'; 2 2 + import * as DrawUtil from '../Util/DrawUtil'; 3 3 + import { Eventable } from '../Interfaces/Index'; 4 4 + import { GameEvent } from '../Events'; 5 5 + import { Actor } from '../Actor'; 6 6 + import { Body } from './Body'; 7 7 + import { CollisionShape } from './CollisionShape'; 8 8 + import { Vector } from '../Algebra'; 9 9 + import { Physics } from '../Physics'; 10 10 + import { BoundingBox } from './BoundingBox'; 11 11 + import { CollisionType } from './CollisionType'; 12 12 + import { CollisionContact } from './CollisionContact'; 13 13 + import { EventDispatcher } from '../EventDispatcher'; 14 14 + import { Pair } from './Pair'; 15 15 + import { Clonable } from '../Interfaces/Clonable'; 16 16 + 17 17 + /** 18 18 + * Type guard function to determine whether something is a Collider 19 19 + */ 20 20 + export function isCollider(x: Actor | Collider): x is Collider { 21 21 + return x instanceof Collider; 22 22 + } 23 23 + 24 24 + export interface ColliderOptions { 25 25 + /** 26 26 + * Optional [[shape|Shape]] to use with this collider, the shape defines the collidable region along with the [[bounding box|BoundingBox]] 27 27 + */ 28 28 + shape?: CollisionShape; 29 29 + /** 30 30 + * Optional body to associate with this collider 31 31 + */ 32 32 + body?: Body; 33 33 + /** 34 34 + * Optional [[collision type|CollisionType]], if not specified the default is [[CollisionType.PreventCollision]] 35 35 + */ 36 36 + type?: CollisionType; 37 37 + /** 38 38 + * Optional local bounds if other bounds are required instead of the bounding box from the shape. This overrides shape bounds. 39 39 + */ 40 40 + localBounds?: BoundingBox; 41 41 + /** 42 42 + * Optional flag to indicate moment of inertia from the shape should be used, by default it is true. 43 43 + */ 44 44 + useShapeInertia?: boolean; 45 45 + } 46 46 + 47 47 + /** 48 48 + * Collider describes material properties like shape, 49 49 + * bounds, friction of the physics object. Only **one** collider can be associated with a body at a time 50 50 + */ 51 51 + 52 52 + export class Collider implements Eventable, Clonable<Collider> { 53 53 + private _shape: CollisionShape; 54 54 + public useShapeInertia: boolean; 55 55 + private _events: EventDispatcher<Collider> = new EventDispatcher<Collider>(this); 56 56 + 57 57 + constructor({ body, type, shape, useShapeInertia = true }: ColliderOptions) { 58 58 + // If shape is not supplied see if the body has an existing collider with a shape 59 59 + if (body && body.collider && !shape) { 60 60 + this._shape = body.collider.shape; 61 61 + } else { 62 62 + this._shape = shape; 63 63 + this.body = body; 64 64 + } 65 65 + this.useShapeInertia = useShapeInertia; 66 66 + this._shape.collider = this; 67 67 + this.type = type; 68 68 + } 69 69 + 70 70 + /** 71 71 + * Returns a clone of the current collider, not associated with any body 72 72 + */ 73 73 + public clone() { 74 74 + return new Collider({ 75 75 + body: null, 76 76 + type: this.type, 77 77 + shape: this._shape.clone() 78 78 + }); 79 79 + } 80 80 + 81 81 + /** 82 82 + * Get the unique id of the collider 83 83 + */ 84 84 + public get id(): number { 85 85 + return this.body ? this.body.id : -1; 86 86 + } 87 87 + 88 88 + /** 89 89 + * Gets or sets the current collision type of this collider. By 90 90 + * default it is ([[CollisionType.PreventCollision]]). 91 91 + */ 92 92 + public type: CollisionType = CollisionType.PreventCollision; 93 93 + 94 94 + /** 95 95 + * Get the shape of the collider as a [[CollisionShape]] 96 96 + */ 97 97 + public get shape(): CollisionShape { 98 98 + return this._shape; 99 99 + } 100 100 + 101 101 + /** 102 102 + * Set the shape of the collider as a [[CollisionShape]], if useShapeInertia is set the collider will use inertia from the shape. 103 103 + */ 104 104 + public set shape(shape: CollisionShape) { 105 105 + this._shape = shape; 106 106 + this._shape.collider = this; 107 107 + if (this.useShapeInertia) { 108 108 + this.inertia = isNaN(this._shape.inertia) ? this.inertia : this._shape.inertia; 109 109 + } 110 110 + } 111 111 + 112 112 + /** 113 113 + * Return a reference to the body associated with this collider 114 114 + */ 115 115 + public body: Body; 116 116 + 117 117 + /** 118 118 + * The center of the collider in world space 119 119 + */ 120 120 + public get center(): Vector { 121 121 + return this.bounds.center; 122 122 + } 123 123 + 124 124 + /** 125 125 + * Is this collider active, if false it wont collide 126 126 + */ 127 127 + public get active(): boolean { 128 128 + return this.body.active; 129 129 + } 130 130 + 131 131 + /** 132 132 + * Collide 2 colliders and product a collision contact if there is a collision, null if none 133 133 + * 134 134 + * Collision vector is in the direction of the other collider. Away from this collider, this -> other. 135 135 + * @param other 136 136 + */ 137 137 + public collide(other: Collider): CollisionContact | null { 138 138 + return this.shape.collide(other.shape); 139 139 + } 140 140 + 141 141 + /** 142 142 + * The current mass of the actor, mass can be thought of as the resistance to acceleration. 143 143 + */ 144 144 + public mass: number = 1.0; 145 145 + 146 146 + /** 147 147 + * The current moment of inertia, moment of inertia can be thought of as the resistance to rotation. 148 148 + */ 149 149 + public inertia: number = 1000; 150 150 + 151 151 + /** 152 152 + * The coefficient of friction on this actor 153 153 + */ 154 154 + public friction: number = 0.99; 155 155 + 156 156 + /** 157 157 + * The also known as coefficient of restitution of this actor, represents the amount of energy preserved after collision or the 158 158 + * bounciness. If 1, it is 100% bouncy, 0 it completely absorbs. 159 159 + */ 160 160 + public bounciness: number = 0.2; 161 161 + 162 162 + /** 163 163 + * Returns a boolean indicating whether this body collided with 164 164 + * or was in stationary contact with 165 165 + * the body of the other [[Collider]] 166 166 + */ 167 167 + public touching(other: Collider): boolean { 168 168 + const pair = new Pair(this, other); 169 169 + pair.collide(); 170 170 + 171 171 + if (pair.collision) { 172 172 + return true; 173 173 + } 174 174 + 175 175 + return false; 176 176 + } 177 177 + 178 178 + /** 179 179 + * Returns the collider's [[BoundingBox]] calculated for this instant in world space. 180 180 + * If there is no shape, a point bounding box is returned 181 181 + */ 182 182 + public get bounds(): BoundingBox { 183 183 + if (this.shape) { 184 184 + return this.shape.bounds; 185 185 + } 186 186 + 187 187 + if (this.body) { 188 188 + return new BoundingBox().translate(this.body.pos); 189 189 + } 190 190 + return new BoundingBox(); 191 191 + } 192 192 + 193 193 + /** 194 194 + * Returns the collider's [[BoundingBox]] relative to the body's position. 195 195 + * If there is no shape, a point boudning box is returned 196 196 + */ 197 197 + public get localBounds(): BoundingBox { 198 198 + if (this.shape) { 199 199 + return this.shape.localBounds; 200 200 + } 201 201 + return new BoundingBox(); 202 202 + } 203 203 + 204 204 + /** 205 205 + * Updates the collision shapes geometry and internal caches if needed 206 206 + */ 207 207 + public update() { 208 208 + if (this.shape) { 209 209 + this.shape.recalc(); 210 210 + } 211 211 + } 212 212 + 213 213 + emit(eventName: string, event: GameEvent<Collider>): void { 214 214 + this._events.emit(eventName, event); 215 215 + } 216 216 + on(eventName: string, handler: (event: GameEvent<Collider>) => void): void { 217 217 + this._events.on(eventName, handler); 218 218 + } 219 219 + off(eventName: string, handler?: (event: GameEvent<Collider>) => void): void { 220 220 + this._events.off(eventName, handler); 221 221 + } 222 222 + once(eventName: string, handler: (event: GameEvent<Collider>) => void): void { 223 223 + this._events.once(eventName, handler); 224 224 + } 225 225 + 226 226 + clear() { 227 227 + this._events.clear(); 228 228 + } 229 229 + 230 230 + /* istanbul ignore next */ 231 231 + public debugDraw(ctx: CanvasRenderingContext2D) { 232 232 + // Draw motion vectors 233 233 + if (Physics.showMotionVectors) { 234 234 + DrawUtil.vector(ctx, Color.Yellow, this.body.pos, this.body.acc.add(Physics.acc)); 235 235 + DrawUtil.vector(ctx, Color.Red, this.body.pos, this.body.vel); 236 236 + DrawUtil.point(ctx, Color.Red, this.body.pos); 237 237 + } 238 238 + 239 239 + if (Physics.showBounds) { 240 240 + this.bounds.debugDraw(ctx, Color.Yellow); 241 241 + } 242 242 + 243 243 + if (Physics.showArea) { 244 244 + this.shape.debugDraw(ctx, Color.Green); 245 245 + } 246 246 + } 247 247 + }

-76

src/engine/Collision/CollisionArea.ts

Reviewed

··· 1 1 - import { Color } from '../Drawing/Color'; 2 2 - import { CollisionContact } from './CollisionContact'; 3 3 - import { Body } from './Body'; 4 4 - import { BoundingBox } from './BoundingBox'; 5 5 - import { Vector, Projection, Ray } from '../Algebra'; 6 6 - 7 7 - /** 8 8 - * A collision area is a region of space that can detect when other collision areas intersect 9 9 - * for the purposes of colliding 2 objects in excalibur. 10 10 - */ 11 11 - export interface CollisionArea { 12 12 - /** 13 13 - * Position of the collision area relative to the actor if it exists 14 14 - */ 15 15 - pos: Vector; 16 16 - 17 17 - /** 18 18 - * Reference to the actor associated with this collision area 19 19 - */ 20 20 - body: Body; 21 21 - 22 22 - /** 23 23 - * The center point of the collision area, for example if the area is a circle it would be the center. 24 24 - */ 25 25 - getCenter(): Vector; 26 26 - 27 27 - /** 28 28 - * Find the furthest point on the convex hull of this particular area in a certain direction. 29 29 - */ 30 30 - getFurthestPoint(direction: Vector): Vector; 31 31 - 32 32 - /** 33 33 - * Return the axis-aligned bounding box of the collision area 34 34 - */ 35 35 - getBounds(): BoundingBox; 36 36 - 37 37 - /** 38 38 - * Return the axes of this particular shape 39 39 - */ 40 40 - getAxes(): Vector[]; 41 41 - 42 42 - /** 43 43 - * Return the calculated moment of intertia for this area 44 44 - */ 45 45 - getMomentOfInertia(): number; 46 46 - 47 47 - // All new ICollisionAreas need to do the following 48 48 - // Create a new collision function in the CollisionJumpTable against all the primitives 49 49 - // Currently there are 3 primitive collision areas 3! = 6 jump functions 50 50 - collide(area: CollisionArea): CollisionContact; 51 51 - 52 52 - /** 53 53 - * Return wether the area contains a point inclusive to it's border 54 54 - */ 55 55 - contains(point: Vector): boolean; 56 56 - 57 57 - /** 58 58 - * Return the point on the border of the collision area that intersects with a ray (if any). 59 59 - */ 60 60 - rayCast(ray: Ray, max?: number): Vector; 61 61 - 62 62 - /** 63 63 - * Create a projection of this area along an axis. Think of this as casting a "shadow" along an axis 64 64 - */ 65 65 - project(axis: Vector): Projection; 66 66 - 67 67 - /** 68 68 - * Recalculates internal caches and values 69 69 - */ 70 70 - recalc(): void; 71 71 - 72 72 - /** 73 73 - * Draw any debug information 74 74 - */ 75 75 - debugDraw(ctx: CanvasRenderingContext2D, color: Color): void; 76 76 - }

+52 -55

src/engine/Collision/CollisionContact.ts

Reviewed

··· 1 1 - import { CollisionArea } from './CollisionArea'; 2 1 import { Body } from './Body'; 3 3 - 4 4 - import { Actor, CollisionType } from '../Actor'; 5 2 import { Vector } from '../Algebra'; 6 3 import { Physics, CollisionResolutionStrategy } from '../Physics'; 7 4 import { PostCollisionEvent, PreCollisionEvent } from '../Events'; 8 5 import * as Util from '../Util/Util'; 6 6 + import { CollisionType } from './CollisionType'; 7 7 + import { Collider } from './Collider'; 9 8 10 9 /** 11 11 - * Collision contacts are used internally by Excalibur to resolve collision between actors. This 10 10 + * Collision contacts are used internally by Excalibur to resolve collision between colliders. This 12 11 * Pair prevents collisions from being evaluated more than one time 13 12 */ 14 13 export class CollisionContact { ··· 17 16 */ 18 17 id: string; 19 18 /** 20 20 - * The first rigid body in the collision 19 19 + * The first collider in the collision 21 20 */ 22 22 - bodyA: CollisionArea; 21 21 + colliderA: Collider; 23 22 /** 24 24 - * The second rigid body in the collision 23 23 + * The second collider in the collision 25 24 */ 26 26 - bodyB: CollisionArea; 25 25 + colliderB: Collider; 27 26 /** 28 28 - * The minimum translation vector to resolve penetration, pointing away from bodyA 27 27 + * The minimum translation vector to resolve penetration, pointing away from colliderA 29 28 */ 30 29 mtv: Vector; 31 30 /** 32 32 - * The point of collision shared between bodyA and bodyB 31 31 + * The point of collision shared between colliderA and colliderB 33 32 */ 34 33 point: Vector; 35 34 /** 36 36 - * The collision normal, pointing away from bodyA 35 35 + * The collision normal, pointing away from colliderA 37 36 */ 38 37 normal: Vector; 39 38 40 40 - constructor(bodyA: CollisionArea, bodyB: CollisionArea, mtv: Vector, point: Vector, normal: Vector) { 41 41 - this.bodyA = bodyA; 42 42 - this.bodyB = bodyB; 39 39 + constructor(colliderA: Collider, colliderB: Collider, mtv: Vector, point: Vector, normal: Vector) { 40 40 + this.colliderA = colliderA; 41 41 + this.colliderB = colliderB; 43 42 this.mtv = mtv; 44 43 this.point = point; 45 44 this.normal = normal; ··· 55 54 } 56 55 } 57 56 58 58 - private _applyBoxImpulse(bodyA: Actor, bodyB: Actor, mtv: Vector) { 59 59 - if (bodyA.collisionType === CollisionType.Active && bodyB.collisionType !== CollisionType.Passive) { 57 57 + private _applyBoxImpulse(colliderA: Collider, colliderB: Collider, mtv: Vector) { 58 58 + if (colliderA.type === CollisionType.Active && colliderB.type !== CollisionType.Passive) { 60 59 // Resolve overlaps 61 61 - if (bodyA.collisionType === CollisionType.Active && bodyB.collisionType === CollisionType.Active) { 60 60 + if (colliderA.type === CollisionType.Active && colliderB.type === CollisionType.Active) { 62 61 // split overlaps if both are Active 63 62 mtv = mtv.scale(0.5); 64 63 } 65 64 // Apply mtv 66 66 - bodyA.pos.y += mtv.y; 67 67 - bodyA.pos.x += mtv.x; 65 65 + colliderA.body.pos.y += mtv.y; 66 66 + colliderA.body.pos.x += mtv.x; 68 67 69 68 const mtvDir = mtv.normalize(); 70 69 71 70 // only adjust if velocity is opposite 72 72 - if (mtvDir.dot(bodyA.vel) < 0) { 71 71 + if (mtvDir.dot(colliderA.body.vel) < 0) { 73 72 // Cancel out velocity in direction of mtv 74 74 - const velAdj = mtvDir.scale(mtvDir.dot(bodyA.vel.negate())); 73 73 + const velAdj = mtvDir.scale(mtvDir.dot(colliderA.body.vel.negate())); 75 74 76 76 - bodyA.vel = bodyA.vel.add(velAdj); 75 75 + colliderA.body.vel = colliderA.body.vel.add(velAdj); 77 76 } 78 77 79 79 - bodyA.emit('postcollision', new PostCollisionEvent(bodyA, bodyB, Util.getSideFromVector(mtv), mtv)); 78 78 + colliderA.emit('postcollision', new PostCollisionEvent(colliderA, colliderB, Util.getSideFromDirection(mtv), mtv)); 80 79 } 81 80 } 82 81 83 82 private _resolveBoxCollision() { 84 84 - const bodyA = this.bodyA.body.actor; 85 85 - const bodyB = this.bodyB.body.actor; 86 86 - const side = Util.getSideFromVector(this.mtv); 83 83 + const side = Util.getSideFromDirection(this.mtv); 87 84 const mtv = this.mtv.negate(); 88 85 // Publish collision events on both participants 89 89 - bodyA.emit('precollision', new PreCollisionEvent(bodyA, bodyB, side, mtv)); 90 90 - bodyB.emit('precollision', new PreCollisionEvent(bodyB, bodyA, Util.getOppositeSide(side), mtv.negate())); 86 86 + this.colliderA.emit('precollision', new PreCollisionEvent(this.colliderA, this.colliderB, side, mtv)); 87 87 + this.colliderB.emit('precollision', new PreCollisionEvent(this.colliderB, this.colliderA, Util.getOppositeSide(side), mtv.negate())); 91 88 92 92 - this._applyBoxImpulse(bodyA, bodyB, mtv); 93 93 - this._applyBoxImpulse(bodyB, bodyA, mtv.negate()); 89 89 + this._applyBoxImpulse(this.colliderA, this.colliderB, mtv); 90 90 + this._applyBoxImpulse(this.colliderB, this.colliderA, mtv.negate()); 94 91 } 95 92 96 93 private _resolveRigidBodyCollision() { 97 94 // perform collison on bounding areas 98 98 - const bodyA: Body = this.bodyA.body; 99 99 - const bodyB: Body = this.bodyB.body; 100 100 - const mtv = this.mtv; // normal pointing away from bodyA 101 101 - let normal = this.normal; // normal pointing away from bodyA 102 102 - if (bodyA.actor === bodyB.actor) { 95 95 + const bodyA: Body = this.colliderA.body; 96 96 + const bodyB: Body = this.colliderB.body; 97 97 + const mtv = this.mtv; // normal pointing away from colliderA 98 98 + let normal = this.normal; // normal pointing away from colliderA 99 99 + if (bodyA === bodyB) { 103 100 // sanity check for existing pairs 104 101 return; 105 102 } 106 103 107 104 // Publish collision events on both participants 108 108 - const side = Util.getSideFromVector(this.mtv); 109 109 - bodyA.actor.emit('precollision', new PreCollisionEvent(this.bodyA.body.actor, this.bodyB.body.actor, side, this.mtv)); 110 110 - bodyB.actor.emit( 105 105 + const side = Util.getSideFromDirection(this.mtv); 106 106 + this.colliderA.emit('precollision', new PreCollisionEvent(this.colliderA, this.colliderB, side, this.mtv)); 107 107 + this.colliderB.emit( 111 108 'precollision', 112 112 - new PreCollisionEvent(this.bodyB.body.actor, this.bodyA.body.actor, Util.getOppositeSide(side), this.mtv.negate()) 109 109 + new PreCollisionEvent(this.colliderB, this.colliderA, Util.getOppositeSide(side), this.mtv.negate()) 113 110 ); 114 111 115 112 // If any of the participants are passive then short circuit 116 116 - if (bodyA.actor.collisionType === CollisionType.Passive || bodyB.actor.collisionType === CollisionType.Passive) { 113 113 + if (this.colliderA.type === CollisionType.Passive || this.colliderB.type === CollisionType.Passive) { 117 114 return; 118 115 } 119 116 120 120 - const invMassA = bodyA.actor.collisionType === CollisionType.Fixed ? 0 : 1 / bodyA.mass; 121 121 - const invMassB = bodyB.actor.collisionType === CollisionType.Fixed ? 0 : 1 / bodyB.mass; 117 117 + const invMassA = this.colliderA.type === CollisionType.Fixed ? 0 : 1 / this.colliderA.mass; 118 118 + const invMassB = this.colliderB.type === CollisionType.Fixed ? 0 : 1 / this.colliderB.mass; 122 119 123 123 - const invMoiA = bodyA.actor.collisionType === CollisionType.Fixed ? 0 : 1 / bodyA.moi; 124 124 - const invMoiB = bodyB.actor.collisionType === CollisionType.Fixed ? 0 : 1 / bodyB.moi; 120 120 + const invMoiA = this.colliderA.type === CollisionType.Fixed ? 0 : 1 / this.colliderA.inertia; 121 121 + const invMoiB = this.colliderB.type === CollisionType.Fixed ? 0 : 1 / this.colliderB.inertia; 125 122 126 123 // average restitution more relistic 127 127 - const coefRestitution = Math.min(bodyA.restitution, bodyB.restitution); 124 124 + const coefRestitution = Math.min(this.colliderA.bounciness, this.colliderB.bounciness); 128 125 129 129 - const coefFriction = Math.min(bodyA.friction, bodyB.friction); 126 126 + const coefFriction = Math.min(this.colliderA.friction, this.colliderB.friction); 130 127 131 128 normal = normal.normalize(); 132 129 const tangent = normal.normal().normalize(); 133 130 134 134 - const ra = this.point.sub(this.bodyA.getCenter()); // point relative to bodyA position 135 135 - const rb = this.point.sub(this.bodyB.getCenter()); /// point relative to bodyB 131 131 + const ra = this.point.sub(this.colliderA.center); // point relative to colliderA position 132 132 + const rb = this.point.sub(this.colliderB.center); /// point relative to colliderB 136 133 137 134 // Relative velocity in linear terms 138 135 // Angular to linear velocity formula -> omega = v/r ··· 156 153 const impulse = 157 154 -((1 + coefRestitution) * rvNormal) / (invMassA + invMassB + invMoiA * raTangent * raTangent + invMoiB * rbTangent * rbTangent); 158 155 159 159 - if (bodyA.actor.collisionType === CollisionType.Fixed) { 156 156 + if (this.colliderA.type === CollisionType.Fixed) { 160 157 bodyB.vel = bodyB.vel.add(normal.scale(impulse * invMassB)); 161 158 if (Physics.allowRigidBodyRotation) { 162 159 bodyB.rx -= impulse * invMoiB * -rb.cross(normal); 163 160 } 164 161 bodyB.addMtv(mtv); 165 165 - } else if (bodyB.actor.collisionType === CollisionType.Fixed) { 162 162 + } else if (this.colliderB.type === CollisionType.Fixed) { 166 163 bodyA.vel = bodyA.vel.sub(normal.scale(impulse * invMassA)); 167 164 if (Physics.allowRigidBodyRotation) { 168 165 bodyA.rx += impulse * invMoiA * -ra.cross(normal); ··· 200 197 frictionImpulse = t.scale(-impulse * coefFriction); 201 198 } 202 199 203 203 - if (bodyA.actor.collisionType === CollisionType.Fixed) { 200 200 + if (this.colliderA.type === CollisionType.Fixed) { 204 201 // apply frictional impulse 205 202 bodyB.vel = bodyB.vel.add(frictionImpulse.scale(invMassB)); 206 203 if (Physics.allowRigidBodyRotation) { 207 204 bodyB.rx += frictionImpulse.dot(t) * invMoiB * rb.cross(t); 208 205 } 209 209 - } else if (bodyB.actor.collisionType === CollisionType.Fixed) { 206 206 + } else if (this.colliderB.type === CollisionType.Fixed) { 210 207 // apply frictional impulse 211 208 bodyA.vel = bodyA.vel.sub(frictionImpulse.scale(invMassA)); 212 209 if (Physics.allowRigidBodyRotation) { ··· 225 222 } 226 223 } 227 224 228 228 - bodyA.actor.emit('postcollision', new PostCollisionEvent(this.bodyA.body.actor, this.bodyB.body.actor, side, this.mtv)); 229 229 - bodyB.actor.emit( 225 225 + this.colliderA.emit('postcollision', new PostCollisionEvent(this.colliderA, this.colliderB, side, this.mtv)); 226 226 + this.colliderB.emit( 230 227 'postcollision', 231 231 - new PostCollisionEvent(this.bodyB.body.actor, this.bodyA.body.actor, Util.getOppositeSide(side), this.mtv.negate()) 228 228 + new PostCollisionEvent(this.colliderB, this.colliderA, Util.getOppositeSide(side), this.mtv.negate()) 232 229 ); 233 230 } 234 231 }

+44 -25

src/engine/Collision/CollisionJumpTable.ts

Reviewed

··· 1 1 - import { CircleArea } from './CircleArea'; 1 1 + import { Circle } from './Circle'; 2 2 import { CollisionContact } from './CollisionContact'; 3 3 - import { PolygonArea } from './PolygonArea'; 4 4 - import { EdgeArea } from './EdgeArea'; 3 3 + import { ConvexPolygon } from './ConvexPolygon'; 4 4 + import { Edge } from './Edge'; 5 5 6 6 import { Vector } from '../Algebra'; 7 7 8 8 export let CollisionJumpTable = { 9 9 - CollideCircleCircle(circleA: CircleArea, circleB: CircleArea): CollisionContact { 9 9 + CollideCircleCircle(circleA: Circle, circleB: Circle): CollisionContact { 10 10 const radius = circleA.radius + circleB.radius; 11 11 - const circleAPos = circleA.body.pos.add(circleA.pos); 12 12 - const circleBPos = circleB.body.pos.add(circleB.pos); 11 11 + const circleAPos = circleA.worldPos; 12 12 + const circleBPos = circleB.worldPos; 13 13 if (circleAPos.distance(circleBPos) > radius) { 14 14 return null; 15 15 } ··· 19 19 20 20 const pointOfCollision = circleA.getFurthestPoint(axisOfCollision); 21 21 22 22 - return new CollisionContact(circleA, circleB, mvt, pointOfCollision, axisOfCollision); 22 22 + return new CollisionContact(circleA.collider, circleB.collider, mvt, pointOfCollision, axisOfCollision); 23 23 }, 24 24 25 25 - CollideCirclePolygon(circle: CircleArea, polygon: PolygonArea): CollisionContact { 25 25 + CollideCirclePolygon(circle: Circle, polygon: ConvexPolygon): CollisionContact { 26 26 let minAxis = circle.testSeparatingAxisTheorem(polygon); 27 27 if (!minAxis) { 28 28 return null; 29 29 } 30 30 31 31 // make sure that the minAxis is pointing away from circle 32 32 - const samedir = minAxis.dot(polygon.getCenter().sub(circle.getCenter())); 32 32 + const samedir = minAxis.dot(polygon.center.sub(circle.center)); 33 33 minAxis = samedir < 0 ? minAxis.negate() : minAxis; 34 34 35 35 const verts: Vector[] = []; ··· 46 46 return null; 47 47 } 48 48 49 49 - return new CollisionContact(circle, polygon, minAxis, verts.length === 2 ? verts[0].average(verts[1]) : verts[0], minAxis.normalize()); 49 49 + return new CollisionContact( 50 50 + circle.collider, 51 51 + polygon.collider, 52 52 + minAxis, 53 53 + verts.length === 2 ? verts[0].average(verts[1]) : verts[0], 54 54 + minAxis.normalize() 55 55 + ); 50 56 }, 51 57 52 52 - CollideCircleEdge(circle: CircleArea, edge: EdgeArea): CollisionContact { 58 58 + CollideCircleEdge(circle: Circle, edge: Edge): CollisionContact { 53 59 // center of the circle 54 54 - const cc = circle.getCenter(); 60 60 + const cc = circle.center; 55 61 // vector in the direction of the edge 56 62 const e = edge.end.sub(edge.begin); 57 63 ··· 67 73 if (dda > circle.radius * circle.radius) { 68 74 return null; // no collision 69 75 } 70 70 - return new CollisionContact(circle, edge, da.normalize().scale(circle.radius - Math.sqrt(dda)), edge.begin, da.normalize()); 76 76 + return new CollisionContact( 77 77 + circle.collider, 78 78 + edge.collider, 79 79 + da.normalize().scale(circle.radius - Math.sqrt(dda)), 80 80 + edge.begin, 81 81 + da.normalize() 82 82 + ); 71 83 } 72 84 73 85 // Potential region B collision (circle is on the right side of the edge, after the end) ··· 77 89 if (ddb > circle.radius * circle.radius) { 78 90 return null; 79 91 } 80 80 - return new CollisionContact(circle, edge, db.normalize().scale(circle.radius - Math.sqrt(ddb)), edge.end, db.normalize()); 92 92 + return new CollisionContact( 93 93 + circle.collider, 94 94 + edge.collider, 95 95 + db.normalize().scale(circle.radius - Math.sqrt(ddb)), 96 96 + edge.end, 97 97 + db.normalize() 98 98 + ); 81 99 } 82 100 83 101 // Otherwise potential region AB collision (circle is in the middle of the edge between the beginning and end) ··· 103 121 n = n.normalize(); 104 122 105 123 const mvt = n.scale(Math.abs(circle.radius - Math.sqrt(dd))); 106 106 - return new CollisionContact(circle, edge, mvt.negate(), pointOnEdge, n.negate()); 124 124 + return new CollisionContact(circle.collider, edge.collider, mvt.negate(), pointOnEdge, n.negate()); 107 125 }, 108 126 109 127 CollideEdgeEdge(): CollisionContact { ··· 111 129 return null; 112 130 }, 113 131 114 114 - CollidePolygonEdge(polygon: PolygonArea, edge: EdgeArea): CollisionContact { 132 132 + CollidePolygonEdge(polygon: ConvexPolygon, edge: Edge): CollisionContact { 115 133 // 3 cases: 116 134 // (1) Polygon lands on the full face 117 135 // (2) Polygon lands on the right point ··· 123 141 if (polygon.contains(edge.begin)) { 124 142 const { distance: mtv, face } = polygon.getClosestFace(edge.begin); 125 143 if (mtv) { 126 126 - return new CollisionContact(polygon, edge, mtv.negate(), edge.begin.add(mtv.negate()), face.normal().negate()); 144 144 + return new CollisionContact(polygon.collider, edge.collider, mtv.negate(), edge.begin.add(mtv.negate()), face.normal().negate()); 127 145 } 128 146 } 129 147 130 148 if (polygon.contains(edge.end)) { 131 149 const { distance: mtv, face } = polygon.getClosestFace(edge.end); 132 150 if (mtv) { 133 133 - return new CollisionContact(polygon, edge, mtv.negate(), edge.end.add(mtv.negate()), face.normal().negate()); 151 151 + return new CollisionContact(polygon.collider, edge.collider, mtv.negate(), edge.end.add(mtv.negate()), face.normal().negate()); 134 152 } 135 153 } 136 154 137 137 - const pc = polygon.getCenter(); 138 138 - const ec = edge.getCenter(); 155 155 + const pc = polygon.center; 156 156 + const ec = edge.center; 139 157 const dir = ec.sub(pc).normalize(); 140 158 141 159 // build a temporary polygon from the edge to use SAT 142 142 - const linePoly = new PolygonArea({ 160 160 + const linePoly = new ConvexPolygon({ 161 161 + collider: edge.collider, 143 162 points: [edge.begin, edge.end, edge.end.add(dir.scale(30)), edge.begin.add(dir.scale(30))] 144 163 }); 145 164 ··· 154 173 edgeNormal = edgeNormal.dot(dir) < 0 ? edgeNormal.negate() : edgeNormal; 155 174 minAxis = minAxis.dot(dir) < 0 ? minAxis.negate() : minAxis; 156 175 157 157 - return new CollisionContact(polygon, edge, minAxis, polygon.getFurthestPoint(edgeNormal), edgeNormal); 176 176 + return new CollisionContact(polygon.collider, edge.collider, minAxis, polygon.getFurthestPoint(edgeNormal), edgeNormal); 158 177 }, 159 178 160 160 - CollidePolygonPolygon(polyA: PolygonArea, polyB: PolygonArea): CollisionContact { 179 179 + CollidePolygonPolygon(polyA: ConvexPolygon, polyB: ConvexPolygon): CollisionContact { 161 180 // do a SAT test to find a min axis if it exists 162 181 let minAxis = polyA.testSeparatingAxisTheorem(polyB); 163 182 ··· 167 186 } 168 187 169 188 // make sure that minAxis is pointing from A -> B 170 170 - const sameDir = minAxis.dot(polyB.getCenter().sub(polyA.getCenter())); 189 189 + const sameDir = minAxis.dot(polyB.center.sub(polyA.center)); 171 190 minAxis = sameDir < 0 ? minAxis.negate() : minAxis; 172 191 173 192 // find rough point of collision ··· 190 209 191 210 const contact = verts.length === 2 ? verts[0].add(verts[1]).scale(0.5) : verts[0]; 192 211 193 193 - return new CollisionContact(polyA, polyB, minAxis, contact, minAxis.normalize()); 212 212 + return new CollisionContact(polyA.collider, polyB.collider, minAxis, contact, minAxis.normalize()); 194 213 } 195 214 };

+2 -3

src/engine/Collision/CollisionResolver.ts

Reviewed

··· 1 1 import { Body } from './Body'; 2 2 import { FrameStats } from '../Debug'; 3 3 import { Pair } from './Pair'; 4 4 - import { Actor } from '../Actor'; 5 4 import { CollisionResolutionStrategy } from '../Physics'; 6 5 7 6 /** ··· 21 20 /** 22 21 * Detect potential collision pairs 23 22 */ 24 24 - broadphase(targets: Actor[], delta: number, stats?: FrameStats): Pair[]; 23 23 + broadphase(targets: Body[], delta: number, stats?: FrameStats): Pair[]; 25 24 26 25 /** 27 26 * Identify actual collisions from those pairs, and calculate collision impulse ··· 41 40 /** 42 41 * Update the internal structures to track bodies 43 42 */ 44 44 - update(targets: Actor[], delta: number): number; 43 43 + update(targets: Body[], delta: number): number; 45 44 46 45 /** 47 46 * Draw any debug information

+106

src/engine/Collision/CollisionShape.ts

Reviewed

··· 1 1 + import { Color } from '../Drawing/Color'; 2 2 + import { CollisionContact } from './CollisionContact'; 3 3 + import { Body } from './Body'; 4 4 + import { BoundingBox } from './BoundingBox'; 5 5 + import { Vector, Projection, Ray } from '../Algebra'; 6 6 + import { Collider } from './Collider'; 7 7 + import { Clonable } from '../Interfaces/Clonable'; 8 8 + 9 9 + /** 10 10 + * A collision shape specifies the geometry that can detect when other collision shapes intersect 11 11 + * for the purposes of colliding 2 objects in excalibur. 12 12 + */ 13 13 + export interface CollisionShape extends Clonable<CollisionShape> { 14 14 + /** 15 15 + * Position of the collision shape relative to the collider, by default (0, 0) meaning the shape is positioned on top of the collider. 16 16 + */ 17 17 + pos: Vector; 18 18 + 19 19 + /** 20 20 + * Postion of the collision shape in world coordinates 21 21 + */ 22 22 + worldPos: Vector; 23 23 + 24 24 + /** 25 25 + * Reference to the actor associated with this collision shape 26 26 + * @obsolete Will be removed in v0.24.0 please use [[collider]] 27 27 + */ 28 28 + body: Body; 29 29 + 30 30 + /** 31 31 + * Reference to the collider associated with this collision shape geometry 32 32 + */ 33 33 + collider?: Collider; 34 34 + 35 35 + /** 36 36 + * The center point of the collision shape, for example if the shape is a circle it would be the center. 37 37 + */ 38 38 + center: Vector; 39 39 + 40 40 + /** 41 41 + * Find the furthest point on the convex hull of this particular shape in a certain direction. 42 42 + */ 43 43 + getFurthestPoint(direction: Vector): Vector; 44 44 + 45 45 + /** 46 46 + * Return the axis-aligned bounding box of the collision shape in world coordinates 47 47 + */ 48 48 + bounds: BoundingBox; 49 49 + 50 50 + /** 51 51 + * Return the axis-aligned boudning box of the collision shape in local coordinates 52 52 + */ 53 53 + localBounds: BoundingBox; 54 54 + 55 55 + /** 56 56 + * Return the axes of this particular shape 57 57 + */ 58 58 + axes: Vector[]; 59 59 + 60 60 + /** 61 61 + * Return the calculated moment of intertia for this shape 62 62 + */ 63 63 + inertia: number; 64 64 + 65 65 + // All new CollisionShape need to do the following 66 66 + // Create a new collision function in the CollisionJumpTable against all the primitives 67 67 + // Currently there are 3 primitive collision shape 3! = 6 jump functions 68 68 + collide(shape: CollisionShape): CollisionContact; 69 69 + 70 70 + /** 71 71 + * Return wether the shape contains a point inclusive to it's border 72 72 + */ 73 73 + contains(point: Vector): boolean; 74 74 + 75 75 + /** 76 76 + * Return the point on the border of the collision shape that intersects with a ray (if any). 77 77 + */ 78 78 + rayCast(ray: Ray, max?: number): Vector; 79 79 + 80 80 + /** 81 81 + * Create a projection of this shape along an axis. Think of this as casting a "shadow" along an axis 82 82 + */ 83 83 + project(axis: Vector): Projection; 84 84 + 85 85 + /** 86 86 + * Recalculates internal caches and values 87 87 + */ 88 88 + recalc(): void; 89 89 + 90 90 + /** 91 91 + * Draw the shape 92 92 + * @param ctx 93 93 + * @param color 94 94 + */ 95 95 + draw(ctx: CanvasRenderingContext2D, color?: Color, pos?: Vector): void; 96 96 + 97 97 + /** 98 98 + * Draw any debug information 99 99 + */ 100 100 + debugDraw(ctx: CanvasRenderingContext2D, color: Color): void; 101 101 + } 102 102 + 103 103 + /** 104 104 + * @obsolete Use interface [[CollisionShape]], CollisionArea will be deprecated in v0.24.0 105 105 + */ 106 106 + export interface CollisionArea extends CollisionShape {}

+30

src/engine/Collision/CollisionType.ts

Reviewed

··· 1 1 + /** 2 2 + * An enum that describes the types of collisions actors can participate in 3 3 + */ 4 4 + export enum CollisionType { 5 5 + /** 6 6 + * Actors with the `PreventCollision` setting do not participate in any 7 7 + * collisions and do not raise collision events. 8 8 + */ 9 9 + PreventCollision = 'PreventCollision', 10 10 + /** 11 11 + * Actors with the `Passive` setting only raise collision events, but are not 12 12 + * influenced or moved by other actors and do not influence or move other actors. 13 13 + */ 14 14 + Passive = 'Passive', 15 15 + /** 16 16 + * Actors with the `Active` setting raise collision events and participate 17 17 + * in collisions with other actors and will be push or moved by actors sharing 18 18 + * the `Active` or `Fixed` setting. 19 19 + */ 20 20 + Active = 'Active', 21 21 + /** 22 22 + * Actors with the `Fixed` setting raise collision events and participate in 23 23 + * collisions with other actors. Actors with the `Fixed` setting will not be 24 24 + * pushed or moved by other actors sharing the `Fixed`. Think of Fixed 25 25 + * actors as "immovable/onstoppable" objects. If two `Fixed` actors meet they will 26 26 + * not be pushed or moved by each other, they will not interact except to throw 27 27 + * collision events. 28 28 + */ 29 29 + Fixed = 'Fixed' 30 30 + }

+421

src/engine/Collision/ConvexPolygon.ts

Reviewed

··· 1 1 + import { Color } from '../Drawing/Color'; 2 2 + import { Physics } from '../Physics'; 3 3 + import { BoundingBox } from './BoundingBox'; 4 4 + import { Edge } from './Edge'; 5 5 + import { CollisionJumpTable } from './CollisionJumpTable'; 6 6 + import { Circle } from './Circle'; 7 7 + import { CollisionContact } from './CollisionContact'; 8 8 + import { CollisionShape } from './CollisionShape'; 9 9 + import { Body } from './Body'; 10 10 + import { Vector, Line, Ray, Projection } from '../Algebra'; 11 11 + import { Collider } from './Collider'; 12 12 + 13 13 + export interface ConvexPolygonOptions { 14 14 + /** 15 15 + * Point relative to a collider's position 16 16 + */ 17 17 + 18 18 + pos?: Vector; 19 19 + /** 20 20 + * Points in the polygon in order around the perimeter in local coordinates 21 21 + */ 22 22 + points: Vector[]; 23 23 + /** 24 24 + * Whether points are specified in clockwise or counter clockwise order, default counter-clockwise 25 25 + */ 26 26 + clockwiseWinding?: boolean; 27 27 + /** 28 28 + * Collider to associate optionally with this shape 29 29 + */ 30 30 + collider?: Collider; 31 31 + /** 32 32 + * @obsolete Will be removed in v0.24.0 please use [[collider]] to set and retrieve body information 33 33 + */ 34 34 + 35 35 + body?: Body; 36 36 + } 37 37 + 38 38 + /** 39 39 + * Polygon collision shape for detecting collisions 40 40 + * 41 41 + * Example: 42 42 + * [[include:BoxAndPolygonShape.md]] 43 43 + */ 44 44 + export class ConvexPolygon implements CollisionShape { 45 45 + public pos: Vector; 46 46 + public points: Vector[]; 47 47 + 48 48 + /** 49 49 + * @obsolete Will be removed in v0.24.0 please use [[collider]] to set and retrieve body information 50 50 + */ 51 51 + public body: Body; 52 52 + 53 53 + /** 54 54 + * Collider associated with this shape 55 55 + */ 56 56 + public collider?: Collider; 57 57 + 58 58 + private _transformedPoints: Vector[] = []; 59 59 + private _axes: Vector[] = []; 60 60 + private _sides: Line[] = []; 61 61 + 62 62 + constructor(options: ConvexPolygonOptions) { 63 63 + this.pos = options.pos || Vector.Zero; 64 64 + const winding = !!options.clockwiseWinding; 65 65 + this.points = (winding ? options.points.reverse() : options.points) || []; 66 66 + this.collider = this.collider = options.collider || null; 67 67 + 68 68 + // @obsolete Remove next release in v0.24.0, code exists for backwards compat 69 69 + if (options.body) { 70 70 + this.collider = options.body.collider; 71 71 + this.body = this.collider.body; 72 72 + } 73 73 + // ================================== 74 74 + 75 75 + // calculate initial transformation 76 76 + this._calculateTransformation(); 77 77 + } 78 78 + 79 79 + /** 80 80 + * Returns a clone of this ConvexPolygon, not associated with any collider 81 81 + */ 82 82 + public clone(): ConvexPolygon { 83 83 + return new ConvexPolygon({ 84 84 + pos: this.pos.clone(), 85 85 + points: this.points.map((p) => p.clone()), 86 86 + collider: null, 87 87 + body: null 88 88 + }); 89 89 + } 90 90 + 91 91 + public get worldPos(): Vector { 92 92 + if (this.collider && this.collider.body) { 93 93 + return this.collider.body.pos.add(this.pos); 94 94 + } 95 95 + return this.pos; 96 96 + } 97 97 + 98 98 + /** 99 99 + * Get the center of the collision shape in world coordinates 100 100 + */ 101 101 + public get center(): Vector { 102 102 + const body = this.collider ? this.collider.body : null; 103 103 + if (body) { 104 104 + return body.pos.add(this.pos); 105 105 + } 106 106 + return this.pos; 107 107 + } 108 108 + 109 109 + /** 110 110 + * Calculates the underlying transformation from the body relative space to world space 111 111 + */ 112 112 + private _calculateTransformation() { 113 113 + const body = this.collider ? this.collider.body : null; 114 114 + const pos = body ? body.pos.add(this.pos) : this.pos; 115 115 + const angle = body ? body.rotation : 0; 116 116 + const scale = body ? body.scale : Vector.One; 117 117 + 118 118 + const len = this.points.length; 119 119 + this._transformedPoints.length = 0; // clear out old transform 120 120 + for (let i = 0; i < len; i++) { 121 121 + this._transformedPoints[i] = this.points[i] 122 122 + .scale(scale) 123 123 + .rotate(angle) 124 124 + .add(pos); 125 125 + } 126 126 + } 127 127 + 128 128 + /** 129 129 + * Gets the points that make up the polygon in world space, from actor relative space (if specified) 130 130 + */ 131 131 + public getTransformedPoints(): Vector[] { 132 132 + // only recalculate geometry if, hasn't been calculated 133 133 + if ( 134 134 + !this._transformedPoints.length || 135 135 + // or the position or rotation has changed in world space 136 136 + (this.collider && 137 137 + this.collider.body && 138 138 + (!this.collider.body.oldPos.equals(this.collider.body.pos) || 139 139 + this.collider.body.oldRotation !== this.collider.body.rotation || 140 140 + this.collider.body.oldScale !== this.collider.body.scale)) 141 141 + ) { 142 142 + this._calculateTransformation(); 143 143 + } 144 144 + return this._transformedPoints; 145 145 + } 146 146 + 147 147 + /** 148 148 + * Gets the sides of the polygon in world space 149 149 + */ 150 150 + public getSides(): Line[] { 151 151 + if (this._sides.length) { 152 152 + return this._sides; 153 153 + } 154 154 + const lines = []; 155 155 + const points = this.getTransformedPoints(); 156 156 + const len = points.length; 157 157 + for (let i = 0; i < len; i++) { 158 158 + lines.push(new Line(points[i], points[(i - 1 + len) % len])); 159 159 + } 160 160 + this._sides = lines; 161 161 + return this._sides; 162 162 + } 163 163 + 164 164 + public recalc(): void { 165 165 + this._sides.length = 0; 166 166 + this._axes.length = 0; 167 167 + this._transformedPoints.length = 0; 168 168 + this.getTransformedPoints(); 169 169 + this.getSides(); 170 170 + } 171 171 + 172 172 + /** 173 173 + * Tests if a point is contained in this collision shape in world space 174 174 + */ 175 175 + public contains(point: Vector): boolean { 176 176 + // Always cast to the right, as long as we cast in a consitent fixed direction we 177 177 + // will be fine 178 178 + const testRay = new Ray(point, new Vector(1, 0)); 179 179 + const intersectCount = this.getSides().reduce(function(accum, side) { 180 180 + if (testRay.intersect(side) >= 0) { 181 181 + return accum + 1; 182 182 + } 183 183 + return accum; 184 184 + }, 0); 185 185 + 186 186 + if (intersectCount % 2 === 0) { 187 187 + return false; 188 188 + } 189 189 + return true; 190 190 + } 191 191 + 192 192 + /** 193 193 + * Returns a collision contact if the 2 collision shapes collide, otherwise collide will 194 194 + * return null. 195 195 + * @param shape 196 196 + */ 197 197 + public collide(shape: CollisionShape): CollisionContact { 198 198 + if (shape instanceof Circle) { 199 199 + return CollisionJumpTable.CollideCirclePolygon(shape, this); 200 200 + } else if (shape instanceof ConvexPolygon) { 201 201 + return CollisionJumpTable.CollidePolygonPolygon(this, shape); 202 202 + } else if (shape instanceof Edge) { 203 203 + return CollisionJumpTable.CollidePolygonEdge(this, shape); 204 204 + } else { 205 205 + throw new Error(`Polygon could not collide with unknown CollisionShape ${typeof shape}`); 206 206 + } 207 207 + } 208 208 + 209 209 + /** 210 210 + * Find the point on the shape furthest in the direction specified 211 211 + */ 212 212 + public getFurthestPoint(direction: Vector): Vector { 213 213 + const pts = this.getTransformedPoints(); 214 214 + let furthestPoint = null; 215 215 + let maxDistance = -Number.MAX_VALUE; 216 216 + for (let i = 0; i < pts.length; i++) { 217 217 + const distance = direction.dot(pts[i]); 218 218 + if (distance > maxDistance) { 219 219 + maxDistance = distance; 220 220 + furthestPoint = pts[i]; 221 221 + } 222 222 + } 223 223 + return furthestPoint; 224 224 + } 225 225 + 226 226 + /** 227 227 + * Finds the closes face to the point using perpendicular distance 228 228 + * @param point point to test against polygon 229 229 + */ 230 230 + public getClosestFace(point: Vector): { distance: Vector; face: Line } { 231 231 + const sides = this.getSides(); 232 232 + let min = Number.POSITIVE_INFINITY; 233 233 + let faceIndex = -1; 234 234 + let distance = -1; 235 235 + for (let i = 0; i < sides.length; i++) { 236 236 + const dist = sides[i].distanceToPoint(point); 237 237 + if (dist < min) { 238 238 + min = dist; 239 239 + faceIndex = i; 240 240 + distance = dist; 241 241 + } 242 242 + } 243 243 + 244 244 + if (faceIndex !== -1) { 245 245 + return { 246 246 + distance: sides[faceIndex].normal().scale(distance), 247 247 + face: sides[faceIndex] 248 248 + }; 249 249 + } 250 250 + 251 251 + return null; 252 252 + } 253 253 + 254 254 + /** 255 255 + * Get the axis aligned bounding box for the polygon shape in world coordinates 256 256 + */ 257 257 + public get bounds(): BoundingBox { 258 258 + const points = this.getTransformedPoints(); 259 259 + 260 260 + return BoundingBox.fromPoints(points); 261 261 + } 262 262 + 263 263 + /** 264 264 + * Get the axis aligned bounding box for the polygon shape in local coordinates 265 265 + */ 266 266 + public get localBounds(): BoundingBox { 267 267 + return BoundingBox.fromPoints(this.points); 268 268 + } 269 269 + 270 270 + /** 271 271 + * Get the moment of inertia for an arbitrary polygon 272 272 + * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 273 273 + */ 274 274 + public get inertia(): number { 275 275 + const mass = this.collider ? this.collider.mass : Physics.defaultMass; 276 276 + let numerator = 0; 277 277 + let denominator = 0; 278 278 + for (let i = 0; i < this.points.length; i++) { 279 279 + const iplusone = (i + 1) % this.points.length; 280 280 + const crossTerm = this.points[iplusone].cross(this.points[i]); 281 281 + numerator += 282 282 + crossTerm * 283 283 + (this.points[i].dot(this.points[i]) + this.points[i].dot(this.points[iplusone]) + this.points[iplusone].dot(this.points[iplusone])); 284 284 + denominator += crossTerm; 285 285 + } 286 286 + return (mass / 6) * (numerator / denominator); 287 287 + } 288 288 + 289 289 + /** 290 290 + * Casts a ray into the polygon and returns a vector representing the point of contact (in world space) or null if no collision. 291 291 + */ 292 292 + public rayCast(ray: Ray, max: number = Infinity) { 293 293 + // find the minimum contact time greater than 0 294 294 + // contact times less than 0 are behind the ray and we don't want those 295 295 + const sides = this.getSides(); 296 296 + const len = sides.length; 297 297 + let minContactTime = Number.MAX_VALUE; 298 298 + let contactIndex = -1; 299 299 + for (let i = 0; i < len; i++) { 300 300 + const contactTime = ray.intersect(sides[i]); 301 301 + if (contactTime >= 0 && contactTime < minContactTime && contactTime <= max) { 302 302 + minContactTime = contactTime; 303 303 + contactIndex = i; 304 304 + } 305 305 + } 306 306 + 307 307 + // contact was found 308 308 + if (contactIndex >= 0) { 309 309 + return ray.getPoint(minContactTime); 310 310 + } 311 311 + 312 312 + // no contact found 313 313 + return null; 314 314 + } 315 315 + 316 316 + /** 317 317 + * Get the axis associated with the convex polygon 318 318 + */ 319 319 + public get axes(): Vector[] { 320 320 + if (this._axes.length) { 321 321 + return this._axes; 322 322 + } 323 323 + 324 324 + const axes = []; 325 325 + const points = this.getTransformedPoints(); 326 326 + const len = points.length; 327 327 + for (let i = 0; i < len; i++) { 328 328 + axes.push(points[i].sub(points[(i + 1) % len]).normal()); 329 329 + } 330 330 + this._axes = axes; 331 331 + return this._axes; 332 332 + } 333 333 + 334 334 + /** 335 335 + * Perform Separating Axis test against another polygon, returns null if no overlap in polys 336 336 + * Reference http://www.dyn4j.org/2010/01/sat/ 337 337 + */ 338 338 + public testSeparatingAxisTheorem(other: ConvexPolygon): Vector { 339 339 + const poly1 = this; 340 340 + const poly2 = other; 341 341 + const axes = poly1.axes.concat(poly2.axes); 342 342 + 343 343 + let minOverlap = Number.MAX_VALUE; 344 344 + let minAxis = null; 345 345 + let minIndex = -1; 346 346 + for (let i = 0; i < axes.length; i++) { 347 347 + const proj1 = poly1.project(axes[i]); 348 348 + const proj2 = poly2.project(axes[i]); 349 349 + const overlap = proj1.getOverlap(proj2); 350 350 + if (overlap <= 0) { 351 351 + return null; 352 352 + } else { 353 353 + if (overlap < minOverlap) { 354 354 + minOverlap = overlap; 355 355 + minAxis = axes[i]; 356 356 + minIndex = i; 357 357 + } 358 358 + } 359 359 + } 360 360 + 361 361 + // Sanity check 362 362 + if (minIndex === -1) { 363 363 + return null; 364 364 + } 365 365 + 366 366 + return minAxis.normalize().scale(minOverlap); 367 367 + } 368 368 + 369 369 + /** 370 370 + * Project the edges of the polygon along a specified axis 371 371 + */ 372 372 + public project(axis: Vector): Projection { 373 373 + const points = this.getTransformedPoints(); 374 374 + const len = points.length; 375 375 + let min = Number.MAX_VALUE; 376 376 + let max = -Number.MAX_VALUE; 377 377 + for (let i = 0; i < len; i++) { 378 378 + const scalar = points[i].dot(axis); 379 379 + min = Math.min(min, scalar); 380 380 + max = Math.max(max, scalar); 381 381 + } 382 382 + 383 383 + return new Projection(min, max); 384 384 + } 385 385 + 386 386 + public draw(ctx: CanvasRenderingContext2D, color: Color = Color.Green, pos: Vector = Vector.Zero) { 387 387 + ctx.beginPath(); 388 388 + ctx.fillStyle = color.toString(); 389 389 + const newPos = pos.add(this.pos); 390 390 + // Iterate through the supplied points and construct a 'polygon' 391 391 + const firstPoint = this.points[0].add(newPos); 392 392 + ctx.moveTo(firstPoint.x, firstPoint.y); 393 393 + this.points.map((p) => p.add(newPos)).forEach(function(point) { 394 394 + ctx.lineTo(point.x, point.y); 395 395 + }); 396 396 + ctx.lineTo(firstPoint.x, firstPoint.y); 397 397 + ctx.closePath(); 398 398 + ctx.fill(); 399 399 + } 400 400 + 401 401 + /* istanbul ignore next */ 402 402 + public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Red) { 403 403 + ctx.beginPath(); 404 404 + ctx.strokeStyle = color.toString(); 405 405 + // Iterate through the supplied points and construct a 'polygon' 406 406 + const firstPoint = this.getTransformedPoints()[0]; 407 407 + ctx.moveTo(firstPoint.x, firstPoint.y); 408 408 + this.getTransformedPoints().forEach(function(point) { 409 409 + ctx.lineTo(point.x, point.y); 410 410 + }); 411 411 + ctx.lineTo(firstPoint.x, firstPoint.y); 412 412 + ctx.closePath(); 413 413 + ctx.stroke(); 414 414 + } 415 415 + } 416 416 + 417 417 + /** 418 418 + * @obsolete Use [[ConvexPolygonOptions]], PolygonAreaOptions will be removed in v0.24.0 419 419 + */ 420 420 + export interface PolygonAreaOptions extends ConvexPolygonOptions {} 421 421 + export class PolygonArea extends ConvexPolygon {}

+10 -12

src/engine/Collision/DynamicTree.ts

Reviewed

··· 201 201 public trackBody(body: Body) { 202 202 const node = new TreeNode(); 203 203 node.body = body; 204 204 - node.bounds = body.getBounds(); 204 204 + node.bounds = body.collider.bounds; 205 205 node.bounds.left -= 2; 206 206 node.bounds.top -= 2; 207 207 node.bounds.right += 2; 208 208 node.bounds.bottom += 2; 209 209 - this.nodes[body.actor.id] = node; 209 209 + this.nodes[body.id] = node; 210 210 this._insert(node); 211 211 } 212 212 ··· 214 214 * Updates the dynamic tree given the current bounds of each body being tracked 215 215 */ 216 216 public updateBody(body: Body) { 217 217 - const node = this.nodes[body.actor.id]; 217 217 + const node = this.nodes[body.id]; 218 218 if (!node) { 219 219 return false; 220 220 } 221 221 - const b = body.getBounds(); 221 221 + const b = body.collider.bounds; 222 222 223 223 // if the body is outside the world no longer update it 224 224 if (!this.worldBounds.contains(b)) { 225 225 - Logger.getInstance().warn( 226 226 - 'Actor with id ' + body.actor.id + ' is outside the world bounds and will no longer be tracked for physics' 227 227 - ); 225 225 + Logger.getInstance().warn('Collider with id ' + body.id + ' is outside the world bounds and will no longer be tracked for physics'); 228 226 this.untrackBody(body); 229 227 return false; 230 228 } ··· 263 261 * Untracks a body from the dynamic tree 264 262 */ 265 263 public untrackBody(body: Body) { 266 266 - const node = this.nodes[body.actor.id]; 264 264 + const node = this.nodes[body.collider.id]; 267 265 if (!node) { 268 266 return; 269 267 } 270 268 this._remove(node); 271 271 - this.nodes[body.actor.id] = null; 272 272 - delete this.nodes[body.actor.id]; 269 269 + this.nodes[body.collider.id] = null; 270 270 + delete this.nodes[body.collider.id]; 273 271 } 274 272 275 273 /** ··· 407 405 * the tree until all possible colliders have been returned. 408 406 */ 409 407 public query(body: Body, callback: (other: Body) => boolean): void { 410 410 - const bounds = body.getBounds(); 408 408 + const bounds = body.collider.bounds; 411 409 const helper = (currentNode: TreeNode): boolean => { 412 412 - if (currentNode && currentNode.bounds.collides(bounds)) { 410 410 + if (currentNode && currentNode.bounds.intersect(bounds)) { 413 411 if (currentNode.isLeaf() && currentNode.body !== body) { 414 412 if (callback.call(body, currentNode.body)) { 415 413 return true;

+38 -36

src/engine/Collision/DynamicTreeCollisionBroadphase.ts

Reviewed

··· 5 5 import { Body } from './Body'; 6 6 7 7 import { Vector, Ray } from '../Algebra'; 8 8 - import { Actor, CollisionType } from '../Actor'; 9 8 import { FrameStats } from '../Debug'; 10 9 import { CollisionResolutionStrategy } from '../Physics'; 11 10 import { Logger } from '../Util/Log'; 12 11 import { CollisionStartEvent, CollisionEndEvent } from '../Events'; 12 12 + import { CollisionType } from './CollisionType'; 13 13 + import { Collider } from './Collider'; 13 14 14 15 export class DynamicTreeCollisionBroadphase implements CollisionBroadphase { 15 16 private _dynamicCollisionTree = new DynamicTree(); ··· 40 41 this._dynamicCollisionTree.untrackBody(target); 41 42 } 42 43 43 43 - private _shouldGenerateCollisionPair(actorA: Actor, actorB: Actor) { 44 44 + private _shouldGenerateCollisionPair(colliderA: Collider, colliderB: Collider) { 44 45 // if the collision pair has been calculated already short circuit 45 45 - const hash = Pair.calculatePairHash(actorA.body, actorB.body); 46 46 + const hash = Pair.calculatePairHash(colliderA, colliderB); 46 47 if (this._collisionHash[hash]) { 47 48 return false; // pair exists easy exit return false 48 49 } 49 50 50 50 - return Pair.canCollide(actorA, actorB); 51 51 + return Pair.canCollide(colliderA, colliderB); 51 52 } 52 53 53 54 /** 54 55 * Detects potential collision pairs in a broadphase approach with the dynamic aabb tree strategy 55 56 */ 56 56 - public broadphase(targets: Actor[], delta: number, stats?: FrameStats): Pair[] { 57 57 + public broadphase(targets: Body[], delta: number, stats?: FrameStats): Pair[] { 57 58 const seconds = delta / 1000; 59 59 + 58 60 // Retrieve the list of potential colliders, exclude killed, prevented, and self 59 59 - const potentialColliders = targets.filter((other) => { 60 60 - return !other.isKilled() && other.collisionType !== CollisionType.PreventCollision; 61 61 + const potentialColliders = targets.map((t) => t.collider).filter((other) => { 62 62 + return other.active && other.type !== CollisionType.PreventCollision; 61 63 }); 62 64 63 65 // clear old list of collision pairs ··· 65 67 this._collisionHash = {}; 66 68 67 69 // check for normal collision pairs 68 68 - let actor: Actor; 70 70 + let collider: Collider; 69 71 for (let j = 0, l = potentialColliders.length; j < l; j++) { 70 70 - actor = potentialColliders[j]; 72 72 + collider = potentialColliders[j]; 71 73 72 74 // Query the collision tree for potential colliders 73 73 - this._dynamicCollisionTree.query(actor.body, (other: Body) => { 74 74 - if (this._shouldGenerateCollisionPair(actor, other.actor)) { 75 75 - const pair = new Pair(actor.body, other); 75 75 + this._dynamicCollisionTree.query(collider.body, (other: Body) => { 76 76 + if (this._shouldGenerateCollisionPair(collider, other.collider)) { 77 77 + const pair = new Pair(collider, other.collider); 76 78 this._collisionHash[pair.id] = true; 77 79 this._collisionPairCache.push(pair); 78 80 } ··· 87 89 // Check dynamic tree for fast moving objects 88 90 // Fast moving objects are those moving at least there smallest bound per frame 89 91 if (Physics.checkForFastBodies) { 90 90 - for (const actor of potentialColliders) { 92 92 + for (const collider of potentialColliders) { 91 93 // Skip non-active objects. Does not make sense on other collison types 92 92 - if (actor.collisionType !== CollisionType.Active) { 94 94 + if (collider.type !== CollisionType.Active) { 93 95 continue; 94 96 } 95 97 96 98 // Maximum travel distance next frame 97 99 const updateDistance = 98 98 - actor.vel.magnitude() * seconds + // velocity term 99 99 - actor.acc.magnitude() * 0.5 * seconds * seconds; // acc term 100 100 + collider.body.vel.magnitude() * seconds + // velocity term 101 101 + collider.body.acc.magnitude() * 0.5 * seconds * seconds; // acc term 100 102 101 103 // Find the minimum dimension 102 102 - const minDimension = Math.min(actor.body.getBounds().getHeight(), actor.body.getBounds().getWidth()); 104 104 + const minDimension = Math.min(collider.bounds.height, collider.bounds.width); 103 105 if (Physics.disableMinimumSpeedForFastBody || updateDistance > minDimension / 2) { 104 106 if (stats) { 105 107 stats.physics.fastBodies++; ··· 107 109 108 110 // start with the oldPos because the integration for actors has already happened 109 111 // objects resting on a surface may be slightly penatrating in the current position 110 110 - const updateVec = actor.pos.sub(actor.oldPos); 111 111 - const centerPoint = actor.body.collisionArea.getCenter(); 112 112 - const furthestPoint = actor.body.collisionArea.getFurthestPoint(actor.vel); 112 112 + const updateVec = collider.body.pos.sub(collider.body.oldPos); 113 113 + const centerPoint = collider.shape.center; 114 114 + const furthestPoint = collider.shape.getFurthestPoint(collider.body.vel); 113 115 const origin: Vector = furthestPoint.sub(updateVec); 114 116 115 115 - const ray: Ray = new Ray(origin, actor.vel); 117 117 + const ray: Ray = new Ray(origin, collider.body.vel); 116 118 117 119 // back the ray up by -2x surfaceEpsilon to account for fast moving objects starting on the surface 118 120 ray.pos = ray.pos.add(ray.dir.scale(-2 * Physics.surfaceEpsilon)); 119 121 let minBody: Body; 120 122 let minTranslate: Vector = new Vector(Infinity, Infinity); 121 123 this._dynamicCollisionTree.rayCastQuery(ray, updateDistance + Physics.surfaceEpsilon * 2, (other: Body) => { 122 122 - if (actor.body !== other && other.collisionArea) { 123 123 - const hitPoint = other.collisionArea.rayCast(ray, updateDistance + Physics.surfaceEpsilon * 10); 124 124 + if (collider.body !== other && other.collider.shape) { 125 125 + const hitPoint = other.collider.shape.rayCast(ray, updateDistance + Physics.surfaceEpsilon * 10); 124 126 if (hitPoint) { 125 127 const translate = hitPoint.sub(origin); 126 128 if (translate.magnitude() < minTranslate.magnitude()) { ··· 133 135 }); 134 136 135 137 if (minBody && Vector.isValid(minTranslate)) { 136 136 - const pair = new Pair(actor.body, minBody); 138 138 + const pair = new Pair(collider, minBody.collider); 137 139 if (!this._collisionHash[pair.id]) { 138 140 this._collisionHash[pair.id] = true; 139 141 this._collisionPairCache.push(pair); ··· 141 143 // move the fast moving object to the other body 142 144 // need to push into the surface by ex.Physics.surfaceEpsilon 143 145 const shift = centerPoint.sub(furthestPoint); 144 144 - actor.pos = origin 146 146 + collider.body.pos = origin 145 147 .add(shift) 146 148 .add(minTranslate) 147 149 .add(ray.dir.scale(2 * Physics.surfaceEpsilon)); 148 148 - actor.body.collisionArea.recalc(); 150 150 + collider.shape.recalc(); 149 151 150 152 if (stats) { 151 153 stats.physics.fastBodyCollisions++; ··· 181 183 pair.resolve(strategy); 182 184 183 185 if (pair.collision) { 184 184 - pair.bodyA.applyMtv(); 185 185 - pair.bodyB.applyMtv(); 186 186 + pair.colliderA.body.applyMtv(); 187 187 + pair.colliderB.body.applyMtv(); 186 188 // todo still don't like this, this is a small integration step to resolve narrowphase collisions 187 187 - pair.bodyA.actor.integrate(delta * Physics.collisionShift); 188 188 - pair.bodyB.actor.integrate(delta * Physics.collisionShift); 189 189 + pair.colliderA.body.integrate(delta * Physics.collisionShift); 190 190 + pair.colliderB.body.integrate(delta * Physics.collisionShift); 189 191 } 190 192 } 191 193 ··· 201 203 202 204 // find all new collisions 203 205 if (!this._lastFramePairsHash[p.id]) { 204 204 - const actor1 = p.bodyA.actor; 205 205 - const actor2 = p.bodyB.actor; 206 206 + const actor1 = p.colliderA; 207 207 + const actor2 = p.colliderB; 206 208 actor1.emit('collisionstart', new CollisionStartEvent(actor1, actor2, p)); 207 209 actor2.emit('collisionstart', new CollisionStartEvent(actor2, actor1, p)); 208 210 } ··· 211 213 // find all old collisions 212 214 for (const p of this._lastFramePairs) { 213 215 if (!currentFrameHash[p.id]) { 214 214 - const actor1 = p.bodyA.actor; 215 215 - const actor2 = p.bodyB.actor; 216 216 + const actor1 = p.colliderA; 217 217 + const actor2 = p.colliderB; 216 218 actor1.emit('collisionend', new CollisionEndEvent(actor1, actor2)); 217 219 actor2.emit('collisionend', new CollisionEndEvent(actor2, actor1)); 218 220 } ··· 226 228 /** 227 229 * Update the dynamic tree positions 228 230 */ 229 229 - public update(targets: Actor[]): number { 231 231 + public update(targets: Body[]): number { 230 232 let updated = 0; 231 233 const len = targets.length; 232 234 233 235 for (let i = 0; i < len; i++) { 234 234 - if (this._dynamicCollisionTree.updateBody(targets[i].body)) { 236 236 + if (this._dynamicCollisionTree.updateBody(targets[i])) { 235 237 updated++; 236 238 } 237 239 }

+284

src/engine/Collision/Edge.ts

Reviewed

··· 1 1 + import { Body } from './Body'; 2 2 + import { BoundingBox } from './BoundingBox'; 3 3 + import { CollisionContact } from './CollisionContact'; 4 4 + import { CollisionJumpTable } from './CollisionJumpTable'; 5 5 + import { CollisionShape } from './CollisionShape'; 6 6 + import { Circle } from './Circle'; 7 7 + import { ConvexPolygon } from './ConvexPolygon'; 8 8 + 9 9 + import { Vector, Ray, Projection } from '../Algebra'; 10 10 + import { Physics } from '../Physics'; 11 11 + import { Color } from '../Drawing/Color'; 12 12 + import { Collider } from './Collider'; 13 13 + 14 14 + export interface EdgeOptions { 15 15 + /** 16 16 + * The beginning of the edge defined in local coordinates to the collider 17 17 + */ 18 18 + begin: Vector; 19 19 + /** 20 20 + * The ending of the edge defined in local coordinates to the collider 21 21 + */ 22 22 + end: Vector; 23 23 + /** 24 24 + * Optionally the collider associated with this edge 25 25 + */ 26 26 + collider?: Collider; 27 27 + 28 28 + // @obsolete Will be removed in v0.24.0 please use [[collider]] to set and retrieve body information 29 29 + body?: Body; 30 30 + } 31 31 + 32 32 + /** 33 33 + * Edge is a single line collision shape to create collisions with a single line. 34 34 + * 35 35 + * Example: 36 36 + * [[include:EdgeShape.md]] 37 37 + */ 38 38 + export class Edge implements CollisionShape { 39 39 + body: Body; 40 40 + collider?: Collider; 41 41 + pos: Vector; 42 42 + begin: Vector; 43 43 + end: Vector; 44 44 + 45 45 + constructor(options: EdgeOptions) { 46 46 + this.begin = options.begin || Vector.Zero; 47 47 + this.end = options.end || Vector.Zero; 48 48 + this.collider = options.collider || null; 49 49 + this.pos = this.center; 50 50 + 51 51 + // @obsolete Remove next release in v0.24.0, code exists for backwards compat 52 52 + if (options.body) { 53 53 + this.collider = options.body.collider; 54 54 + this.body = this.collider.body; 55 55 + } 56 56 + // ================================== 57 57 + } 58 58 + 59 59 + /** 60 60 + * Returns a clone of this Edge, not associated with any collider 61 61 + */ 62 62 + public clone(): Edge { 63 63 + return new Edge({ 64 64 + begin: this.begin.clone(), 65 65 + end: this.end.clone(), 66 66 + collider: null, 67 67 + body: null 68 68 + }); 69 69 + } 70 70 + 71 71 + public get worldPos(): Vector { 72 72 + if (this.collider && this.collider.body) { 73 73 + return this.collider.body.pos.add(this.pos); 74 74 + } 75 75 + return this.pos; 76 76 + } 77 77 + 78 78 + /** 79 79 + * Get the center of the collision area in world coordinates 80 80 + */ 81 81 + public get center(): Vector { 82 82 + const pos = this.begin.average(this.end).add(this._getBodyPos()); 83 83 + return pos; 84 84 + } 85 85 + 86 86 + private _getBodyPos(): Vector { 87 87 + let bodyPos = Vector.Zero; 88 88 + if (this.collider && this.collider.body) { 89 89 + bodyPos = this.collider.body.pos; 90 90 + } 91 91 + return bodyPos; 92 92 + } 93 93 + 94 94 + private _getTransformedBegin(): Vector { 95 95 + const body = this.collider ? this.collider.body : null; 96 96 + const angle = body ? body.rotation : 0; 97 97 + return this.begin.rotate(angle).add(this._getBodyPos()); 98 98 + } 99 99 + 100 100 + private _getTransformedEnd(): Vector { 101 101 + const body = this.collider ? this.collider.body : null; 102 102 + const angle = body ? body.rotation : 0; 103 103 + return this.end.rotate(angle).add(this._getBodyPos()); 104 104 + } 105 105 + 106 106 + /** 107 107 + * Returns the slope of the line in the form of a vector 108 108 + */ 109 109 + public getSlope(): Vector { 110 110 + const begin = this._getTransformedBegin(); 111 111 + const end = this._getTransformedEnd(); 112 112 + const distance = begin.distance(end); 113 113 + return end.sub(begin).scale(1 / distance); 114 114 + } 115 115 + 116 116 + /** 117 117 + * Returns the length of the line segment in pixels 118 118 + */ 119 119 + public getLength(): number { 120 120 + const begin = this._getTransformedBegin(); 121 121 + const end = this._getTransformedEnd(); 122 122 + const distance = begin.distance(end); 123 123 + return distance; 124 124 + } 125 125 + 126 126 + /** 127 127 + * Tests if a point is contained in this collision area 128 128 + */ 129 129 + public contains(): boolean { 130 130 + return false; 131 131 + } 132 132 + 133 133 + /** 134 134 + * @inheritdoc 135 135 + */ 136 136 + public rayCast(ray: Ray, max: number = Infinity): Vector { 137 137 + const numerator = this._getTransformedBegin().sub(ray.pos); 138 138 + 139 139 + // Test is line and ray are parallel and non intersecting 140 140 + if (ray.dir.cross(this.getSlope()) === 0 && numerator.cross(ray.dir) !== 0) { 141 141 + return null; 142 142 + } 143 143 + 144 144 + // Lines are parallel 145 145 + const divisor = ray.dir.cross(this.getSlope()); 146 146 + if (divisor === 0) { 147 147 + return null; 148 148 + } 149 149 + 150 150 + const t = numerator.cross(this.getSlope()) / divisor; 151 151 + 152 152 + if (t >= 0 && t <= max) { 153 153 + const u = numerator.cross(ray.dir) / divisor / this.getLength(); 154 154 + if (u >= 0 && u <= 1) { 155 155 + return ray.getPoint(t); 156 156 + } 157 157 + } 158 158 + 159 159 + return null; 160 160 + } 161 161 + 162 162 + /** 163 163 + * @inheritdoc 164 164 + */ 165 165 + public collide(shape: CollisionShape): CollisionContact { 166 166 + if (shape instanceof Circle) { 167 167 + return CollisionJumpTable.CollideCircleEdge(shape, this); 168 168 + } else if (shape instanceof ConvexPolygon) { 169 169 + return CollisionJumpTable.CollidePolygonEdge(shape, this); 170 170 + } else if (shape instanceof Edge) { 171 171 + return CollisionJumpTable.CollideEdgeEdge(); 172 172 + } else { 173 173 + throw new Error(`Edge could not collide with unknown CollisionShape ${typeof shape}`); 174 174 + } 175 175 + } 176 176 + 177 177 + /** 178 178 + * Find the point on the shape furthest in the direction specified 179 179 + */ 180 180 + public getFurthestPoint(direction: Vector): Vector { 181 181 + const transformedBegin = this._getTransformedBegin(); 182 182 + const transformedEnd = this._getTransformedEnd(); 183 183 + if (direction.dot(transformedBegin) > 0) { 184 184 + return transformedBegin; 185 185 + } else { 186 186 + return transformedEnd; 187 187 + } 188 188 + } 189 189 + 190 190 + private _boundsFromBeginEnd(begin: Vector, end: Vector) { 191 191 + return new BoundingBox(Math.min(begin.x, end.x), Math.min(begin.y, end.y), Math.max(begin.x, end.x), Math.max(begin.y, end.y)); 192 192 + } 193 193 + 194 194 + /** 195 195 + * Get the axis aligned bounding box for the edge shape in world space 196 196 + */ 197 197 + public get bounds(): BoundingBox { 198 198 + const transformedBegin = this._getTransformedBegin(); 199 199 + const transformedEnd = this._getTransformedEnd(); 200 200 + return this._boundsFromBeginEnd(transformedBegin, transformedEnd); 201 201 + } 202 202 + 203 203 + public get localBounds(): BoundingBox { 204 204 + return this._boundsFromBeginEnd(this.begin, this.end); 205 205 + } 206 206 + 207 207 + /** 208 208 + * Get the axis associated with the edge 209 209 + */ 210 210 + public get axes(): Vector[] { 211 211 + const e = this._getTransformedEnd().sub(this._getTransformedBegin()); 212 212 + const edgeNormal = e.normal(); 213 213 + 214 214 + const axes = []; 215 215 + axes.push(edgeNormal); 216 216 + axes.push(edgeNormal.negate()); 217 217 + axes.push(edgeNormal.normal()); 218 218 + axes.push(edgeNormal.normal().negate()); 219 219 + return axes; 220 220 + } 221 221 + 222 222 + /** 223 223 + * Get the moment of inertia for an edge 224 224 + * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 225 225 + */ 226 226 + public get inertia(): number { 227 227 + const mass = this.collider ? this.collider.mass : Physics.defaultMass; 228 228 + const length = this.end.sub(this.begin).distance() / 2; 229 229 + return mass * length * length; 230 230 + } 231 231 + 232 232 + /** 233 233 + * @inheritdoc 234 234 + */ 235 235 + public recalc(): void { 236 236 + // edges don't have any cached data 237 237 + } 238 238 + 239 239 + /** 240 240 + * Project the edge along a specified axis 241 241 + */ 242 242 + public project(axis: Vector): Projection { 243 243 + const scalars = []; 244 244 + 245 245 + const points = [this._getTransformedBegin(), this._getTransformedEnd()]; 246 246 + const len = points.length; 247 247 + for (let i = 0; i < len; i++) { 248 248 + scalars.push(points[i].dot(axis)); 249 249 + } 250 250 + 251 251 + return new Projection(Math.min.apply(Math, scalars), Math.max.apply(Math, scalars)); 252 252 + } 253 253 + 254 254 + public draw(ctx: CanvasRenderingContext2D, color: Color = Color.Green, pos: Vector = Vector.Zero) { 255 255 + const begin = this.begin.add(pos); 256 256 + const end = this.end.add(pos); 257 257 + ctx.strokeStyle = color.toString(); 258 258 + ctx.beginPath(); 259 259 + ctx.moveTo(begin.x, begin.y); 260 260 + ctx.lineTo(end.x, end.y); 261 261 + ctx.closePath(); 262 262 + ctx.stroke(); 263 263 + } 264 264 + 265 265 + /* istanbul ignore next */ 266 266 + public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Red) { 267 267 + ctx.strokeStyle = color.toString(); 268 268 + ctx.beginPath(); 269 269 + ctx.moveTo(this.begin.x, this.begin.y); 270 270 + ctx.lineTo(this.end.x, this.end.y); 271 271 + ctx.closePath(); 272 272 + ctx.stroke(); 273 273 + } 274 274 + } 275 275 + 276 276 + /** 277 277 + * @obsolete Use [[EdgeOptions]], EdgeAreaOptions will be removed in v0.24.0 278 278 + */ 279 279 + export interface EdgeAreaOptions extends EdgeOptions {} 280 280 + 281 281 + /** 282 282 + * @obsolete Use [[Edge]], EdgeArea will be removed in v0.24.0 283 283 + */ 284 284 + export class EdgeArea extends Edge {}

-213

src/engine/Collision/EdgeArea.ts

Reviewed

··· 1 1 - import { Body } from './Body'; 2 2 - import { BoundingBox } from './BoundingBox'; 3 3 - import { CollisionContact } from './CollisionContact'; 4 4 - import { CollisionJumpTable } from './CollisionJumpTable'; 5 5 - import { CollisionArea } from './CollisionArea'; 6 6 - import { CircleArea } from './CircleArea'; 7 7 - import { PolygonArea } from './PolygonArea'; 8 8 - 9 9 - import { Vector, Ray, Projection } from '../Algebra'; 10 10 - import { Physics } from '../Physics'; 11 11 - import { Color } from '../Drawing/Color'; 12 12 - 13 13 - export interface EdgeAreaOptions { 14 14 - begin?: Vector; 15 15 - end?: Vector; 16 16 - body?: Body; 17 17 - } 18 18 - 19 19 - export class EdgeArea implements CollisionArea { 20 20 - body: Body; 21 21 - pos: Vector; 22 22 - begin: Vector; 23 23 - end: Vector; 24 24 - 25 25 - constructor(options: EdgeAreaOptions) { 26 26 - this.begin = options.begin || Vector.Zero; 27 27 - this.end = options.end || Vector.Zero; 28 28 - this.body = options.body || null; 29 29 - 30 30 - this.pos = this.getCenter(); 31 31 - } 32 32 - 33 33 - /** 34 34 - * Get the center of the collision area in world coordinates 35 35 - */ 36 36 - public getCenter(): Vector { 37 37 - const pos = this.begin.average(this.end).add(this._getBodyPos()); 38 38 - return pos; 39 39 - } 40 40 - 41 41 - private _getBodyPos(): Vector { 42 42 - let bodyPos = Vector.Zero; 43 43 - if (this.body.pos) { 44 44 - bodyPos = this.body.pos; 45 45 - } 46 46 - return bodyPos; 47 47 - } 48 48 - 49 49 - private _getTransformedBegin(): Vector { 50 50 - const angle = this.body ? this.body.rotation : 0; 51 51 - return this.begin.rotate(angle).add(this._getBodyPos()); 52 52 - } 53 53 - 54 54 - private _getTransformedEnd(): Vector { 55 55 - const angle = this.body ? this.body.rotation : 0; 56 56 - return this.end.rotate(angle).add(this._getBodyPos()); 57 57 - } 58 58 - 59 59 - /** 60 60 - * Returns the slope of the line in the form of a vector 61 61 - */ 62 62 - public getSlope(): Vector { 63 63 - const begin = this._getTransformedBegin(); 64 64 - const end = this._getTransformedEnd(); 65 65 - const distance = begin.distance(end); 66 66 - return end.sub(begin).scale(1 / distance); 67 67 - } 68 68 - 69 69 - /** 70 70 - * Returns the length of the line segment in pixels 71 71 - */ 72 72 - public getLength(): number { 73 73 - const begin = this._getTransformedBegin(); 74 74 - const end = this._getTransformedEnd(); 75 75 - const distance = begin.distance(end); 76 76 - return distance; 77 77 - } 78 78 - 79 79 - /** 80 80 - * Tests if a point is contained in this collision area 81 81 - */ 82 82 - public contains(): boolean { 83 83 - return false; 84 84 - } 85 85 - 86 86 - /** 87 87 - * @inheritdoc 88 88 - */ 89 89 - public rayCast(ray: Ray, max: number = Infinity): Vector { 90 90 - const numerator = this._getTransformedBegin().sub(ray.pos); 91 91 - 92 92 - // Test is line and ray are parallel and non intersecting 93 93 - if (ray.dir.cross(this.getSlope()) === 0 && numerator.cross(ray.dir) !== 0) { 94 94 - return null; 95 95 - } 96 96 - 97 97 - // Lines are parallel 98 98 - const divisor = ray.dir.cross(this.getSlope()); 99 99 - if (divisor === 0) { 100 100 - return null; 101 101 - } 102 102 - 103 103 - const t = numerator.cross(this.getSlope()) / divisor; 104 104 - 105 105 - if (t >= 0 && t <= max) { 106 106 - const u = numerator.cross(ray.dir) / divisor / this.getLength(); 107 107 - if (u >= 0 && u <= 1) { 108 108 - return ray.getPoint(t); 109 109 - } 110 110 - } 111 111 - 112 112 - return null; 113 113 - } 114 114 - 115 115 - /** 116 116 - * @inheritdoc 117 117 - */ 118 118 - public collide(area: CollisionArea): CollisionContact { 119 119 - if (area instanceof CircleArea) { 120 120 - return CollisionJumpTable.CollideCircleEdge(area, this); 121 121 - } else if (area instanceof PolygonArea) { 122 122 - return CollisionJumpTable.CollidePolygonEdge(area, this); 123 123 - } else if (area instanceof EdgeArea) { 124 124 - return CollisionJumpTable.CollideEdgeEdge(); 125 125 - } else { 126 126 - throw new Error(`Edge could not collide with unknown ICollisionArea ${typeof area}`); 127 127 - } 128 128 - } 129 129 - 130 130 - /** 131 131 - * Find the point on the shape furthest in the direction specified 132 132 - */ 133 133 - public getFurthestPoint(direction: Vector): Vector { 134 134 - const transformedBegin = this._getTransformedBegin(); 135 135 - const transformedEnd = this._getTransformedEnd(); 136 136 - if (direction.dot(transformedBegin) > 0) { 137 137 - return transformedBegin; 138 138 - } else { 139 139 - return transformedEnd; 140 140 - } 141 141 - } 142 142 - 143 143 - /** 144 144 - * Get the axis aligned bounding box for the circle area 145 145 - */ 146 146 - public getBounds(): BoundingBox { 147 147 - const transformedBegin = this._getTransformedBegin(); 148 148 - const transformedEnd = this._getTransformedEnd(); 149 149 - return new BoundingBox( 150 150 - Math.min(transformedBegin.x, transformedEnd.x), 151 151 - Math.min(transformedBegin.y, transformedEnd.y), 152 152 - Math.max(transformedBegin.x, transformedEnd.x), 153 153 - Math.max(transformedBegin.y, transformedEnd.y) 154 154 - ); 155 155 - } 156 156 - 157 157 - /** 158 158 - * Get the axis associated with the edge 159 159 - */ 160 160 - public getAxes(): Vector[] { 161 161 - const e = this._getTransformedEnd().sub(this._getTransformedBegin()); 162 162 - const edgeNormal = e.normal(); 163 163 - 164 164 - const axes = []; 165 165 - axes.push(edgeNormal); 166 166 - axes.push(edgeNormal.negate()); 167 167 - axes.push(edgeNormal.normal()); 168 168 - axes.push(edgeNormal.normal().negate()); 169 169 - return axes; 170 170 - } 171 171 - 172 172 - /** 173 173 - * Get the moment of inertia for an edge 174 174 - * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 175 175 - */ 176 176 - public getMomentOfInertia(): number { 177 177 - const mass = this.body ? this.body.mass : Physics.defaultMass; 178 178 - const length = this.end.sub(this.begin).distance() / 2; 179 179 - return mass * length * length; 180 180 - } 181 181 - 182 182 - /** 183 183 - * @inheritdoc 184 184 - */ 185 185 - public recalc(): void { 186 186 - // edges don't have any cached data 187 187 - } 188 188 - 189 189 - /** 190 190 - * Project the edge along a specified axis 191 191 - */ 192 192 - public project(axis: Vector): Projection { 193 193 - const scalars = []; 194 194 - 195 195 - const points = [this._getTransformedBegin(), this._getTransformedEnd()]; 196 196 - const len = points.length; 197 197 - for (let i = 0; i < len; i++) { 198 198 - scalars.push(points[i].dot(axis)); 199 199 - } 200 200 - 201 201 - return new Projection(Math.min.apply(Math, scalars), Math.max.apply(Math, scalars)); 202 202 - } 203 203 - 204 204 - /* istanbul ignore next */ 205 205 - public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Red) { 206 206 - ctx.strokeStyle = color.toString(); 207 207 - ctx.beginPath(); 208 208 - ctx.moveTo(this.begin.x, this.begin.y); 209 209 - ctx.lineTo(this.end.x, this.end.y); 210 210 - ctx.closePath(); 211 211 - ctx.stroke(); 212 212 - } 213 213 - }

+6 -5

src/engine/Collision/Index.ts

Reviewed

··· 1 1 export * from './Body'; 2 2 + export * from './Collider'; 2 3 export * from './BoundingBox'; 3 3 - export * from './CircleArea'; 4 4 + export * from './Circle'; 4 5 export * from './CollisionContact'; 5 6 export * from './CollisionJumpTable'; 6 7 export * from './DynamicTree'; 7 8 export * from './DynamicTreeCollisionBroadphase'; 8 8 - export * from './EdgeArea'; 9 9 - export * from './CollisionArea'; 9 9 + export * from './Edge'; 10 10 + export * from './CollisionShape'; 10 11 export * from './CollisionResolver'; 11 12 export * from './Physics'; 12 12 - export * from './NaiveCollisionBroadphase'; 13 13 export * from './Pair'; 14 14 - export * from './PolygonArea'; 14 14 + export * from './ConvexPolygon'; 15 15 export * from './Side'; 16 16 + export * from './Shape';

-118

src/engine/Collision/NaiveCollisionBroadphase.ts

Reviewed

··· 1 1 - import { Physics } from './../Physics'; 2 2 - import { CollisionContact } from './CollisionContact'; 3 3 - import { Pair } from './Pair'; 4 4 - import { Actor, CollisionType } from './../Actor'; 5 5 - import { CollisionBroadphase } from './CollisionResolver'; 6 6 - import { CollisionStartEvent, CollisionEndEvent } from '../Events'; 7 7 - 8 8 - export class NaiveCollisionBroadphase implements CollisionBroadphase { 9 9 - private _lastFramePairs: Pair[] = []; 10 10 - private _lastFramePairsHash: { [pairId: string]: Pair } = {}; 11 11 - 12 12 - public track() { 13 13 - // pass 14 14 - } 15 15 - 16 16 - public untrack() { 17 17 - // pass 18 18 - } 19 19 - 20 20 - /** 21 21 - * Detects potential collision pairs in a broadphase approach with the dynamic aabb tree strategy 22 22 - */ 23 23 - public broadphase(targets: Actor[]): Pair[] { 24 24 - // Retrieve the list of potential colliders, exclude killed, prevented, and self 25 25 - const potentialColliders = targets.filter((other) => { 26 26 - return !other.isKilled() && other.collisionType !== CollisionType.PreventCollision; 27 27 - }); 28 28 - 29 29 - let actor1: Actor; 30 30 - let actor2: Actor; 31 31 - const collisionPairs: Pair[] = []; 32 32 - 33 33 - for (let j = 0, l = potentialColliders.length; j < l; j++) { 34 34 - actor1 = potentialColliders[j]; 35 35 - 36 36 - for (let i = j + 1; i < l; i++) { 37 37 - actor2 = potentialColliders[i]; 38 38 - 39 39 - let minimumTranslationVector; 40 40 - if ((minimumTranslationVector = actor1.collides(actor2))) { 41 41 - const pair = new Pair(actor1.body, actor2.body); 42 42 - pair.collision = new CollisionContact( 43 43 - actor1.collisionArea, 44 44 - actor2.collisionArea, 45 45 - minimumTranslationVector, 46 46 - actor1.pos, 47 47 - minimumTranslationVector 48 48 - ); 49 49 - if ( 50 50 - !collisionPairs.some((cp) => { 51 51 - return cp.id === pair.id; 52 52 - }) 53 53 - ) { 54 54 - collisionPairs.push(pair); 55 55 - } 56 56 - } 57 57 - } 58 58 - } 59 59 - return collisionPairs; 60 60 - } 61 61 - 62 62 - /** 63 63 - * Identify actual collisions from those pairs, and calculate collision impulse 64 64 - */ 65 65 - public narrowphase(pairs: Pair[]): Pair[] { 66 66 - return pairs; 67 67 - } 68 68 - 69 69 - public runCollisionStartEnd(pairs: Pair[]) { 70 70 - const currentFrameHash: { [pairId: string]: Pair } = {}; 71 71 - 72 72 - for (const p of pairs) { 73 73 - // load currentFrameHash 74 74 - currentFrameHash[p.id] = p; 75 75 - 76 76 - // find all new collisions 77 77 - if (!this._lastFramePairsHash[p.id]) { 78 78 - const actor1 = p.bodyA.actor; 79 79 - const actor2 = p.bodyB.actor; 80 80 - actor1.emit('collisionstart', new CollisionStartEvent(actor1, actor2, p)); 81 81 - actor2.emit('collisionstart', new CollisionStartEvent(actor2, actor1, p)); 82 82 - } 83 83 - } 84 84 - 85 85 - // find all old collisions 86 86 - for (const p of this._lastFramePairs) { 87 87 - if (!currentFrameHash[p.id]) { 88 88 - const actor1 = p.bodyA.actor; 89 89 - const actor2 = p.bodyB.actor; 90 90 - actor1.emit('collisionend', new CollisionEndEvent(actor1, actor2)); 91 91 - actor2.emit('collisionend', new CollisionEndEvent(actor2, actor1)); 92 92 - } 93 93 - } 94 94 - 95 95 - // reset the last frame cache 96 96 - this._lastFramePairs = pairs; 97 97 - this._lastFramePairsHash = currentFrameHash; 98 98 - } 99 99 - 100 100 - /** 101 101 - * Resolve the position and velocity of the physics bodies 102 102 - */ 103 103 - public resolve(pairs: Pair[]): Pair[] { 104 104 - for (const pair of pairs) { 105 105 - pair.resolve(Physics.collisionResolutionStrategy); 106 106 - } 107 107 - 108 108 - return pairs.filter((p) => p.canCollide); 109 109 - } 110 110 - 111 111 - public update(): number { 112 112 - return 0; 113 113 - } 114 114 - 115 115 - public debugDraw() { 116 116 - return; 117 117 - } 118 118 - }

+15 -15

src/engine/Collision/Pair.ts

Reviewed

··· 1 1 import { Physics } from './../Physics'; 2 2 import { Color } from './../Drawing/Color'; 3 3 - import { Body } from './Body'; 4 3 import { CollisionContact } from './CollisionContact'; 5 5 - import { CollisionType, Actor } from '../Actor'; 6 4 import { CollisionResolutionStrategy } from '../Physics'; 7 5 import * as DrawUtil from '../Util/DrawUtil'; 6 6 + import { CollisionType } from './CollisionType'; 7 7 + import { Collider } from './Collider'; 8 8 9 9 /** 10 10 * Models a potential collision between 2 bodies ··· 13 13 public id: string = null; 14 14 public collision: CollisionContact = null; 15 15 16 16 - constructor(public bodyA: Body, public bodyB: Body) { 17 17 - this.id = Pair.calculatePairHash(bodyA, bodyB); 16 16 + constructor(public colliderA: Collider, public colliderB: Collider) { 17 17 + this.id = Pair.calculatePairHash(colliderA, colliderB); 18 18 } 19 19 20 20 - public static canCollide(actorA: Actor, actorB: Actor) { 20 20 + public static canCollide(colliderA: Collider, colliderB: Collider) { 21 21 // if both are fixed short circuit 22 22 - if (actorA.collisionType === CollisionType.Fixed && actorB.collisionType === CollisionType.Fixed) { 22 22 + if (colliderA.type === CollisionType.Fixed && colliderB.type === CollisionType.Fixed) { 23 23 return false; 24 24 } 25 25 26 26 // if the either is prevent collision short circuit 27 27 - if (actorB.collisionType === CollisionType.PreventCollision || actorA.collisionType === CollisionType.PreventCollision) { 27 27 + if (colliderB.type === CollisionType.PreventCollision || colliderA.type === CollisionType.PreventCollision) { 28 28 return false; 29 29 } 30 30 31 31 // if either is dead short circuit 32 32 - if (actorA.isKilled() || actorB.isKilled()) { 32 32 + if (!colliderA.active || !colliderB.active) { 33 33 return false; 34 34 } 35 35 ··· 40 40 * Returns whether or not it is possible for the pairs to collide 41 41 */ 42 42 public get canCollide(): boolean { 43 43 - const actorA = this.bodyA.actor; 44 44 - const actorB = this.bodyB.actor; 43 43 + const actorA = this.colliderA; 44 44 + const actorB = this.colliderB; 45 45 return Pair.canCollide(actorA, actorB); 46 46 } 47 47 ··· 49 49 * Runs the collison intersection logic on the members of this pair 50 50 */ 51 51 public collide() { 52 52 - this.collision = this.bodyA.collisionArea.collide(this.bodyB.collisionArea); 52 52 + this.collision = this.colliderA.collide(this.colliderB); 53 53 } 54 54 55 55 /** ··· 64 64 /** 65 65 * Calculates the unique pair hash id for this collision pair 66 66 */ 67 67 - public static calculatePairHash(bodyA: Body, bodyB: Body): string { 68 68 - if (bodyA.actor.id < bodyB.actor.id) { 69 69 - return `#${bodyA.actor.id}+${bodyB.actor.id}`; 67 67 + public static calculatePairHash(colliderA: Collider, colliderB: Collider): string { 68 68 + if (colliderA.id < colliderB.id) { 69 69 + return `#${colliderA.id}+${colliderB.id}`; 70 70 } else { 71 71 - return `#${bodyB.actor.id}+${bodyA.actor.id}`; 71 71 + return `#${colliderB.id}+${colliderA.id}`; 72 72 } 73 73 } 74 74

-337

src/engine/Collision/PolygonArea.ts

Reviewed

··· 1 1 - import { Color } from './../Drawing/Color'; 2 2 - import { Physics } from './../Physics'; 3 3 - import { BoundingBox } from './BoundingBox'; 4 4 - import { EdgeArea } from './EdgeArea'; 5 5 - import { CollisionJumpTable } from './CollisionJumpTable'; 6 6 - import { CircleArea } from './CircleArea'; 7 7 - import { CollisionContact } from './CollisionContact'; 8 8 - import { CollisionArea } from './CollisionArea'; 9 9 - import { Body } from './Body'; 10 10 - import { Vector, Line, Ray, Projection } from './../Algebra'; 11 11 - 12 12 - export interface PolygonAreaOptions { 13 13 - pos?: Vector; 14 14 - points?: Vector[]; 15 15 - clockwiseWinding?: boolean; 16 16 - body?: Body; 17 17 - } 18 18 - 19 19 - /** 20 20 - * Polygon collision area for detecting collisions for actors, or independently 21 21 - */ 22 22 - export class PolygonArea implements CollisionArea { 23 23 - public pos: Vector; 24 24 - public points: Vector[]; 25 25 - public body: Body; 26 26 - 27 27 - private _transformedPoints: Vector[] = []; 28 28 - private _axes: Vector[] = []; 29 29 - private _sides: Line[] = []; 30 30 - 31 31 - constructor(options: PolygonAreaOptions) { 32 32 - this.pos = options.pos || Vector.Zero; 33 33 - const winding = !!options.clockwiseWinding; 34 34 - this.points = (winding ? options.points.reverse() : options.points) || []; 35 35 - this.body = options.body || null; 36 36 - 37 37 - // calculate initial transformation 38 38 - this._calculateTransformation(); 39 39 - } 40 40 - 41 41 - /** 42 42 - * Get the center of the collision area in world coordinates 43 43 - */ 44 44 - public getCenter(): Vector { 45 45 - if (this.body) { 46 46 - return this.body.pos.add(this.pos); 47 47 - } 48 48 - return this.pos; 49 49 - } 50 50 - 51 51 - /** 52 52 - * Calculates the underlying transformation from the body relative space to world space 53 53 - */ 54 54 - private _calculateTransformation() { 55 55 - const pos = this.body ? this.body.pos.add(this.pos) : this.pos; 56 56 - const angle = this.body ? this.body.rotation : 0; 57 57 - 58 58 - const len = this.points.length; 59 59 - this._transformedPoints.length = 0; // clear out old transform 60 60 - for (let i = 0; i < len; i++) { 61 61 - this._transformedPoints[i] = this.points[i].rotate(angle).add(pos); 62 62 - } 63 63 - } 64 64 - 65 65 - /** 66 66 - * Gets the points that make up the polygon in world space, from actor relative space (if specified) 67 67 - */ 68 68 - public getTransformedPoints(): Vector[] { 69 69 - if (!this._transformedPoints.length) { 70 70 - this._calculateTransformation(); 71 71 - } 72 72 - return this._transformedPoints; 73 73 - } 74 74 - 75 75 - /** 76 76 - * Gets the sides of the polygon in world space 77 77 - */ 78 78 - public getSides(): Line[] { 79 79 - if (this._sides.length) { 80 80 - return this._sides; 81 81 - } 82 82 - const lines = []; 83 83 - const points = this.getTransformedPoints(); 84 84 - const len = points.length; 85 85 - for (let i = 0; i < len; i++) { 86 86 - lines.push(new Line(points[i], points[(i - 1 + len) % len])); 87 87 - } 88 88 - this._sides = lines; 89 89 - return this._sides; 90 90 - } 91 91 - 92 92 - public recalc(): void { 93 93 - this._sides.length = 0; 94 94 - this._axes.length = 0; 95 95 - this._transformedPoints.length = 0; 96 96 - this.getTransformedPoints(); 97 97 - this.getAxes(); 98 98 - this.getSides(); 99 99 - } 100 100 - 101 101 - /** 102 102 - * Tests if a point is contained in this collision area in world space 103 103 - */ 104 104 - public contains(point: Vector): boolean { 105 105 - // Always cast to the right, as long as we cast in a consitent fixed direction we 106 106 - // will be fine 107 107 - const testRay = new Ray(point, new Vector(1, 0)); 108 108 - const intersectCount = this.getSides().reduce(function(accum, side) { 109 109 - if (testRay.intersect(side) >= 0) { 110 110 - return accum + 1; 111 111 - } 112 112 - return accum; 113 113 - }, 0); 114 114 - 115 115 - if (intersectCount % 2 === 0) { 116 116 - return false; 117 117 - } 118 118 - return true; 119 119 - } 120 120 - 121 121 - /** 122 122 - * Returns a collision contact if the 2 collision areas collide, otherwise collide will 123 123 - * return null. 124 124 - * @param area 125 125 - */ 126 126 - public collide(area: CollisionArea): CollisionContact { 127 127 - if (area instanceof CircleArea) { 128 128 - return CollisionJumpTable.CollideCirclePolygon(area, this); 129 129 - } else if (area instanceof PolygonArea) { 130 130 - return CollisionJumpTable.CollidePolygonPolygon(this, area); 131 131 - } else if (area instanceof EdgeArea) { 132 132 - return CollisionJumpTable.CollidePolygonEdge(this, area); 133 133 - } else { 134 134 - throw new Error(`Polygon could not collide with unknown ICollisionArea ${typeof area}`); 135 135 - } 136 136 - } 137 137 - 138 138 - /** 139 139 - * Find the point on the shape furthest in the direction specified 140 140 - */ 141 141 - public getFurthestPoint(direction: Vector): Vector { 142 142 - const pts = this.getTransformedPoints(); 143 143 - let furthestPoint = null; 144 144 - let maxDistance = -Number.MAX_VALUE; 145 145 - for (let i = 0; i < pts.length; i++) { 146 146 - const distance = direction.dot(pts[i]); 147 147 - if (distance > maxDistance) { 148 148 - maxDistance = distance; 149 149 - furthestPoint = pts[i]; 150 150 - } 151 151 - } 152 152 - return furthestPoint; 153 153 - } 154 154 - 155 155 - /** 156 156 - * Finds the closes face to the point using perpendicular distance 157 157 - * @param point point to test against polygon 158 158 - */ 159 159 - public getClosestFace(point: Vector): { distance: Vector; face: Line } { 160 160 - const sides = this.getSides(); 161 161 - let min = Number.POSITIVE_INFINITY; 162 162 - let faceIndex = -1; 163 163 - let distance = -1; 164 164 - for (let i = 0; i < sides.length; i++) { 165 165 - const dist = sides[i].distanceToPoint(point); 166 166 - if (dist < min) { 167 167 - min = dist; 168 168 - faceIndex = i; 169 169 - distance = dist; 170 170 - } 171 171 - } 172 172 - 173 173 - if (faceIndex !== -1) { 174 174 - return { 175 175 - distance: sides[faceIndex].normal().scale(distance), 176 176 - face: sides[faceIndex] 177 177 - }; 178 178 - } 179 179 - 180 180 - return null; 181 181 - } 182 182 - 183 183 - /** 184 184 - * Get the axis aligned bounding box for the polygon area 185 185 - */ 186 186 - public getBounds(): BoundingBox { 187 187 - // todo there is a faster way to do this 188 188 - const points = this.getTransformedPoints(); 189 189 - 190 190 - const minX = points.reduce(function(prev, curr) { 191 191 - return Math.min(prev, curr.x); 192 192 - }, 999999999); 193 193 - const maxX = points.reduce(function(prev, curr) { 194 194 - return Math.max(prev, curr.x); 195 195 - }, -99999999); 196 196 - 197 197 - const minY = points.reduce(function(prev, curr) { 198 198 - return Math.min(prev, curr.y); 199 199 - }, 9999999999); 200 200 - const maxY = points.reduce(function(prev, curr) { 201 201 - return Math.max(prev, curr.y); 202 202 - }, -9999999999); 203 203 - 204 204 - return new BoundingBox(minX, minY, maxX, maxY); 205 205 - } 206 206 - 207 207 - /** 208 208 - * Get the moment of inertia for an arbitrary polygon 209 209 - * https://en.wikipedia.org/wiki/List_of_moments_of_inertia 210 210 - */ 211 211 - public getMomentOfInertia(): number { 212 212 - const mass = this.body ? this.body.mass : Physics.defaultMass; 213 213 - let numerator = 0; 214 214 - let denominator = 0; 215 215 - for (let i = 0; i < this.points.length; i++) { 216 216 - const iplusone = (i + 1) % this.points.length; 217 217 - const crossTerm = this.points[iplusone].cross(this.points[i]); 218 218 - numerator += 219 219 - crossTerm * 220 220 - (this.points[i].dot(this.points[i]) + this.points[i].dot(this.points[iplusone]) + this.points[iplusone].dot(this.points[iplusone])); 221 221 - denominator += crossTerm; 222 222 - } 223 223 - return (mass / 6) * (numerator / denominator); 224 224 - } 225 225 - 226 226 - /** 227 227 - * Casts a ray into the polygon and returns a vector representing the point of contact (in world space) or null if no collision. 228 228 - */ 229 229 - public rayCast(ray: Ray, max: number = Infinity) { 230 230 - // find the minimum contact time greater than 0 231 231 - // contact times less than 0 are behind the ray and we don't want those 232 232 - const sides = this.getSides(); 233 233 - const len = sides.length; 234 234 - let minContactTime = Number.MAX_VALUE; 235 235 - let contactIndex = -1; 236 236 - for (let i = 0; i < len; i++) { 237 237 - const contactTime = ray.intersect(sides[i]); 238 238 - if (contactTime >= 0 && contactTime < minContactTime && contactTime <= max) { 239 239 - minContactTime = contactTime; 240 240 - contactIndex = i; 241 241 - } 242 242 - } 243 243 - 244 244 - // contact was found 245 245 - if (contactIndex >= 0) { 246 246 - return ray.getPoint(minContactTime); 247 247 - } 248 248 - 249 249 - // no contact found 250 250 - return null; 251 251 - } 252 252 - 253 253 - /** 254 254 - * Get the axis associated with the edge 255 255 - */ 256 256 - public getAxes(): Vector[] { 257 257 - if (this._axes.length) { 258 258 - return this._axes; 259 259 - } 260 260 - 261 261 - const axes = []; 262 262 - const points = this.getTransformedPoints(); 263 263 - const len = points.length; 264 264 - for (let i = 0; i < len; i++) { 265 265 - axes.push(points[i].sub(points[(i + 1) % len]).normal()); 266 266 - } 267 267 - this._axes = axes; 268 268 - return this._axes; 269 269 - } 270 270 - 271 271 - /** 272 272 - * Perform Separating Axis test against another polygon, returns null if no overlap in polys 273 273 - * Reference http://www.dyn4j.org/2010/01/sat/ 274 274 - */ 275 275 - public testSeparatingAxisTheorem(other: PolygonArea): Vector { 276 276 - const poly1 = this; 277 277 - const poly2 = other; 278 278 - const axes = poly1.getAxes().concat(poly2.getAxes()); 279 279 - 280 280 - let minOverlap = Number.MAX_VALUE; 281 281 - let minAxis = null; 282 282 - let minIndex = -1; 283 283 - for (let i = 0; i < axes.length; i++) { 284 284 - const proj1 = poly1.project(axes[i]); 285 285 - const proj2 = poly2.project(axes[i]); 286 286 - const overlap = proj1.getOverlap(proj2); 287 287 - if (overlap <= 0) { 288 288 - return null; 289 289 - } else { 290 290 - if (overlap < minOverlap) { 291 291 - minOverlap = overlap; 292 292 - minAxis = axes[i]; 293 293 - minIndex = i; 294 294 - } 295 295 - } 296 296 - } 297 297 - 298 298 - // Sanity check 299 299 - if (minIndex === -1) { 300 300 - return null; 301 301 - } 302 302 - 303 303 - return minAxis.normalize().scale(minOverlap); 304 304 - } 305 305 - 306 306 - /** 307 307 - * Project the edges of the polygon along a specified axis 308 308 - */ 309 309 - public project(axis: Vector): Projection { 310 310 - const points = this.getTransformedPoints(); 311 311 - const len = points.length; 312 312 - let min = Number.MAX_VALUE; 313 313 - let max = -Number.MAX_VALUE; 314 314 - for (let i = 0; i < len; i++) { 315 315 - const scalar = points[i].dot(axis); 316 316 - min = Math.min(min, scalar); 317 317 - max = Math.max(max, scalar); 318 318 - } 319 319 - 320 320 - return new Projection(min, max); 321 321 - } 322 322 - 323 323 - /* istanbul ignore next */ 324 324 - public debugDraw(ctx: CanvasRenderingContext2D, color: Color = Color.Red) { 325 325 - ctx.beginPath(); 326 326 - ctx.strokeStyle = color.toString(); 327 327 - // Iterate through the supplied points and construct a 'polygon' 328 328 - const firstPoint = this.getTransformedPoints()[0]; 329 329 - ctx.moveTo(firstPoint.x, firstPoint.y); 330 330 - this.getTransformedPoints().forEach(function(point) { 331 331 - ctx.lineTo(point.x, point.y); 332 332 - }); 333 333 - ctx.lineTo(firstPoint.x, firstPoint.y); 334 334 - ctx.closePath(); 335 335 - ctx.stroke(); 336 336 - } 337 337 - }

+62

src/engine/Collision/Shape.ts

Reviewed

··· 1 1 + import { ConvexPolygon } from './ConvexPolygon'; 2 2 + import { Circle } from './Circle'; 3 3 + import { Edge } from './Edge'; 4 4 + import { BoundingBox } from './BoundingBox'; 5 5 + import { Vector } from '../Algebra'; 6 6 + 7 7 + /** 8 8 + * Excalibur shape helper for defining collision shapes quickly 9 9 + */ 10 10 + export class Shape { 11 11 + /** 12 12 + * Creates a box collision shape, under the hood defines a [[ConvexPolygon]] collision shape 13 13 + * @param width Width of the box 14 14 + * @param height Height of the box 15 15 + * @param anchor Anchor of the box (default (.5, .5)) which positions the box relative to the center of the collider's position 16 16 + * @param center Optional offset relative to the collider in local coordinates 17 17 + */ 18 18 + static Box(width: number, height: number, anchor: Vector = Vector.Half, center: Vector = Vector.Zero): ConvexPolygon { 19 19 + return new ConvexPolygon({ 20 20 + points: new BoundingBox(-width * anchor.x, -height * anchor.y, width - width * anchor.x, height - height * anchor.y).getPoints(), 21 21 + pos: center 22 22 + }); 23 23 + } 24 24 + 25 25 + /** 26 26 + * Creates a new [[arbitrary polygon|ConvexPolygon]] collision shape 27 27 + * @param points Points specified in counter clockwise 28 28 + * @param clockwiseWinding Optionally changed the winding of points, by default false meaning counter-clockwise winding. 29 29 + * @param center Optional offset relative to the collider in local coordinates 30 30 + */ 31 31 + static Polygon(points: Vector[], clockwiseWinding: boolean = false, center: Vector = Vector.Zero): ConvexPolygon { 32 32 + return new ConvexPolygon({ 33 33 + points: points, 34 34 + pos: center, 35 35 + clockwiseWinding: clockwiseWinding 36 36 + }); 37 37 + } 38 38 + 39 39 + /** 40 40 + * Creates a new [[circle|Circle]] collision shape 41 41 + * @param radius Radius of the circle shape 42 42 + * @param center Optional offset relative to the collider in local coordinates 43 43 + */ 44 44 + static Circle(radius: number, center: Vector = Vector.Zero): Circle { 45 45 + return new Circle({ 46 46 + radius: radius, 47 47 + pos: center 48 48 + }); 49 49 + } 50 50 + 51 51 + /** 52 52 + * Creates a new [[edge|Edge]] collision shape 53 53 + * @param begin Beginning of the edge in local coordinates to the collider 54 54 + * @param end Ending of the edge in local coordinates to the collider 55 55 + */ 56 56 + static Edge(begin: Vector, end: Vector): Edge { 57 57 + return new Edge({ 58 58 + begin: begin, 59 59 + end: end 60 60 + }); 61 61 + } 62 62 + }

+5 -5

src/engine/Collision/Side.ts

Reviewed

··· 2 2 * An enum that describes the sides of an Actor for collision 3 3 */ 4 4 export enum Side { 5 5 - None, 6 6 - Top, 7 7 - Bottom, 8 8 - Left, 9 9 - Right 5 5 + None = 'None', 6 6 + Top = 'Top', 7 7 + Bottom = 'Bottom', 8 8 + Left = 'Left', 9 9 + Right = 'Right' 10 10 }

+10 -77

src/engine/Deprecated.ts

Reviewed

··· 2 2 import { Trait } from './Interfaces/Trait'; 3 3 import { Drawable } from './Interfaces/Drawable'; 4 4 import { CanInitialize, CanActivate, CanDeactivate, CanUpdate, CanDraw, CanBeKilled } from './Interfaces/LifecycleEvents'; 5 5 - import { CollisionArea } from './Collision/CollisionArea'; 5 5 + import { CollisionShape } from './Collision/CollisionShape'; 6 6 import { Eventable } from './Interfaces/Evented'; 7 7 import { PointerEvents } from './Interfaces/PointerEvents'; 8 8 import { CameraStrategy } from './Camera'; ··· 10 10 import { Action } from './Actions/Action'; 11 11 import { ActorArgs, ActorDefaults } from './Actor'; 12 12 import { CapturePointerConfig } from './Traits/CapturePointer'; 13 13 - import { Collidable, CircleAreaOptions, CollisionBroadphase, EdgeAreaOptions, EnginePhysics, PolygonAreaOptions } from './Collision/Index'; 13 13 + import { CircleOptions, CollisionBroadphase, EdgeOptions, EnginePhysics, ConvexPolygonOptions } from './Collision/Index'; 14 14 import { Physics } from './Physics'; 15 15 import { DebugFlags } from './DebugFlags'; 16 16 import { CollidersHash, FrameStatistics, FrameDurationStats, PhysicsStatistics, FrameActorStats } from './Debug'; ··· 33 33 import { Appender } from './Util/Log'; 34 34 35 35 /** 36 36 - * @deprecated Use ActorsUnderPointer, IActorsUnderPointer will be deprecated in v0.23.0 37 36 * @obsolete Use ActorsUnderPointer, IActorsUnderPointer will be deprecated in v0.23.0 38 37 */ 39 38 export type IActorsUnderPointer = ActorsUnderPointer; 40 39 41 40 /** 42 42 - * @deprecated Use AbsolutePosition, IAbsolutePosition will be deprecated in v0.23.0 43 41 * @obsolete Use AbsolutePosition, IAbsolutePosition will be deprecated in v0.23.0 44 42 */ 45 43 export type IAbsolutePosition = AbsolutePosition; 46 44 47 45 /** 48 48 - * @deprecated Use Action, IAction will be deprecated in v0.23.0 49 46 * @obsolete Use Action, IAction will be deprecated in v0.23.0 50 47 */ 51 48 export type IAction = Action; 52 49 53 50 /** 54 54 - * @deprecated Use Actionable, IActionable will be deprecated in v0.23.0 55 51 * @obsolete Use Actionable, IActionable will be deprecated in v0.23.0 56 52 */ 57 53 export type IActionable = Actionable; 58 54 59 55 /** 60 60 - * @deprecated Use ActorArgs, IActorArgs will be deprecated in v0.23.0 61 56 * @obsolete Use ActorArgs, IActorArgs will be deprecated in v0.23.0 62 57 */ 63 58 export type IActorArgs = ActorArgs; 64 59 65 60 /** 66 66 - * @deprecated Use ActorDefaults, IActorDefaults will be deprecated in v0.23.0 67 61 * @obsolete Use ActorDefaults, IActorDefaults will be deprecated in v0.23.0 68 62 */ 69 63 export type IActorDefaults = ActorDefaults; 70 64 71 65 /** 72 72 - * @deprecated Use Trait, IActorTrait will be removed v0.23.0 73 66 * @obsolete Use Trait, IActorTrait will be removed v0.23.0 74 67 */ 75 68 export type IActorTrait = Trait; 76 69 77 70 /** 78 78 - * @deprecated Use AnimationArgs, IAnimationArgs will be removed v0.23.0 79 71 * @obsolete Use AnimationArgs, IAnimationArgs will be removed v0.23.0 80 72 */ 81 73 export type IAnimationArgs = AnimationArgs; 82 74 83 75 /** 84 84 - * @deprecated Use Appender, IAppender will be removed v0.23.0 85 76 * @obsolete Use Appender, IAppender will be removed v0.23.0 86 77 */ 87 78 export type IAppender = Appender; 88 79 89 80 /** 90 90 - * @deprecated Use Audio, IAudio will be removed v0.23.0 91 81 * @obsolete Use Audio, IAudio will be removed v0.23.0 92 82 */ 93 83 export type IAudio = Audio; 94 84 95 85 /** 96 96 - * @deprecated Use AudioImplementation, IAudioImplementation will be removed v0.23.0 97 86 * @obsolete Use AudioImplementation, IAudioImplementation will be removed v0.23.0 98 87 */ 99 88 export type IAudioImplementation = AudioImplementation; 100 89 101 90 /** 102 102 - * @deprecated Use BorderRadius, IBorderRadius will be removed v0.23.0 103 91 * @obsolete Use BorderRadius, IBorderRadius will be removed v0.23.0 104 92 */ 105 93 export type IBorderRadius = BorderRadius; 106 94 107 95 /** 108 108 - * @deprecated Use CanInitialize, ICanInitialize will be removed v0.23.0 109 96 * @obsolete Use CanInitialize, ICanInitialize will be removed v0.23.0 110 97 */ 111 98 export type ICanInitialize = CanInitialize; 112 99 113 100 /** 114 114 - * @deprecated Use CanActivate, ICanActivate will be removed v0.23.0 115 101 * @obsolete Use CanActivate, ICanActivate will be removed v0.23.0 116 102 */ 117 103 export type ICanActivate = CanActivate; 118 104 119 105 /** 120 120 - * @deprecated Use CanDeactivate, ICanDeactivate will be removed v0.23.0 121 106 * @obsolete Use CanDeactivate, ICanDeactivate will be removed v0.23.0 122 107 */ 123 108 export type ICanDeactivate = CanDeactivate; 124 109 125 110 /** 126 126 - * @deprecated Use CanUpdate, ICanUpdate will be removed in v0.23.0 127 111 * @obsolete Use CanUpdate, ICanUpdate will be removed in v0.23.0 128 112 */ 129 113 export type ICanUpdate = CanUpdate; 130 114 131 115 /** 132 132 - * @deprecated Use CanDraw, ICanDraw will be removed in v0.23.0 133 116 * @obsolete Use CanDraw, ICanDraw will be removed in v0.23.0 134 117 */ 135 118 export type ICanDraw = CanDraw; 136 119 137 120 /** 138 138 - * @deprecated Use CanBeKilled, ICanBeKilled will be removed in v0.23.0 139 121 * @obsolete Use CanBeKilled, ICanBeKilled will be removed in v0.23.0 140 122 */ 141 123 export type ICanBeKilled = CanBeKilled; 142 124 143 125 /** 144 144 - * @deprecated Use CameraStrategy, ICameraStrategy will be removed in v0.23.0 145 126 * @obsolete Use CameraStrategy, ICameraStrategy will be removed in v0.23.0 146 127 */ 147 128 export type ICameraStrategy<T> = CameraStrategy<T>; 148 129 149 130 /** 150 150 - * @deprecated Use CellArgs, ICellArgs will be removed in v0.23.0 151 131 * @obsolete Use CellArgs, ICellArgs will be removed in v0.23.0 152 132 */ 153 133 export type ICellArgs = CellArgs; 154 134 155 135 /** 156 156 - * @deprecated Use Collidable, ICollidable will be removed in v0.23.0 157 157 - * @obsolete Use Collidable, ICollidable will be removed in v0.23.0 158 158 - */ 159 159 - export type ICollidable = Collidable; 160 160 - 161 161 - /** 162 162 - * @deprecated Use CollisionArea, ICollisionArea will be removed in v0.23.0 163 163 - * @obsolete Use CollisionArea, ICollisionArea will be removed in v0.23.0 136 136 + * @obsolete Use CollisionShape, ICollisionArea will be removed in v0.23.0 164 137 */ 165 165 - export type ICollisionArea = CollisionArea; 138 138 + export type ICollisionArea = CollisionShape; 166 139 167 140 /** 168 168 - * @deprecated Use DetectedFeatures, IDetectedFeatures will be removed in v0.23.0 169 141 * @obsolete Use DetectedFeatures, IDetectedFeatures will be removed in v0.23.0 170 142 */ 171 143 export type IDetectedFeatures = DetectedFeatures; 172 144 173 145 /** 174 174 - * @deprecated Use ExResponseTypesLookup, IExResponseTypesLookup will be removed in v0.23.0 175 146 * @obsolete Use ExResponseTypesLookup, IExResponseTypesLookup will be removed in v0.23.0 176 147 */ 177 148 export type IExResponseTypesLookup = ExResponseTypesLookup; 178 149 179 150 /** 180 180 - * @deprecated Use Physics, IPhysics will be removed in v0.23.0 181 151 * @obsolete Use Physics, IPhysics will be removed in v0.23.0 182 152 */ 183 153 export type IPhysics = Physics; 184 154 185 155 /** 186 186 - * @deprecated Use DebugFlags, IDebugFlags will be removed in v0.23.0 187 156 * @obsolete Use DebugFlags, IDebugFlags will be removed in v0.23.0 188 157 */ 189 158 export type IDebugFlags = DebugFlags; 190 159 191 160 /** 192 192 - * @deprecated Use CollisionBroadphase, ICollisionBroadphase will be removed in v0.23.0 193 161 * @obsolete Use CollisionBroadphase, ICollisionBroadphase will be removed in v0.23.0 194 162 */ 195 163 export type ICollisionBroadphase = CollisionBroadphase; 196 164 197 165 /** 198 198 - * @deprecated Use CollidersHash, IColliderHash will be removed in v0.23.0 199 166 * @obsolete Use CollidersHash, IColliderHash will be removed in v0.23.0 200 167 */ 201 168 export type IColliderHash = CollidersHash; 202 169 203 170 /** 204 204 - * @deprecated Use CircleAreaOptions, ICircleAreaOptions will be removed in v0.23.0 205 205 - * @obsolete Use CircleAreaOptions, ICircleAreaOptions will be removed in v0.23.0 171 171 + * @obsolete Use CircleOptions, ICircleAreaOptions will be removed in v0.23.0 206 172 */ 207 207 - export type ICircleAreaOptions = CircleAreaOptions; 173 173 + export type ICircleAreaOptions = CircleOptions; 208 174 209 175 /** 210 210 - * @deprecated Use EdgeAreaOptions, IEdgeAreaOptions will be removed in v0.23.0 211 211 - * @obsolete Use EdgeAreaOptions, IEdgeAreaOptions will be removed in v0.23.0 176 176 + * @obsolete Use EdgeOptions, IEdgeAreaOptions will be removed in v0.23.0 212 177 */ 213 213 - export type IEdgeAreaOptions = EdgeAreaOptions; 178 178 + export type IEdgeAreaOptions = EdgeOptions; 214 179 215 180 /** 216 216 - * @deprecated Use PolygonAreaOptions, IPolygonAreaOptions will be removed in v0.23.0 217 217 - * @obsolete Use PolygonAreaOptions, IPolygonAreaOptions will be removed in v0.23.0 181 181 + * @obsolete Use ConvexPolygonOptions, IPolygonAreaOptions will be removed in v0.23.0 218 182 */ 219 219 - export type IPolygonAreaOptions = PolygonAreaOptions; 183 183 + export type IPolygonAreaOptions = ConvexPolygonOptions; 220 184 221 185 /** 222 222 - * @deprecated Use EngineOptions, IEngineOptions will be removed in v0.23.0 223 186 * @obsolete Use EngineOptions, IEngineOptions will be removed in v0.23.0 224 187 */ 225 188 export type IEngineOptions = EngineOptions; 226 189 227 190 /** 228 228 - * @deprecated Use EnginePhysics, IEnginePhysics will be removed in v0.23.0 229 191 * @obsolete Use EnginePhysics, IEnginePhysics will be removed in v0.23.0 230 192 */ 231 193 export type IEnginePhysics = EnginePhysics; 232 194 233 195 /** 234 234 - * @deprecated Use EngineInput, IEngineInput will be removed in v0.23.0 235 196 * @obsolete Use EngineInput, IEngineInput will be removed in v0.23.0 236 197 */ 237 198 export type IEngineInput = EngineInput; 238 199 239 200 /** 240 240 - * @deprecated Use FrameStatistics, IFrameStats will be removed in v0.23.0 241 201 * @obsolete Use FrameStatistics, IFrameStats will be removed in v0.23.0 242 202 */ 243 203 export type IFrameStats = FrameStatistics; 244 204 245 205 /** 246 246 - * @deprecated Use FrameDurationStats, IFrameDurationStats will be removed in v0.23.0 247 206 * @obsolete Use FrameDurationStats, IFrameDurationStats will be removed in v0.23.0 248 207 */ 249 208 export type IFrameDurationStats = FrameDurationStats; 250 209 251 210 /** 252 252 - * @deprecated Use FrameActorStats, IFrameActorStates will be removed in v0.23.0 253 211 * @obsolete Use FrameActorStats, IFrameActorStates will be removed in v0.23.0 254 212 */ 255 213 export type IFrameActorStates = FrameActorStats; 256 214 257 215 /** 258 258 - * @deprecated Use PhysicsStatistics, IPhysicsStats will be removed in v0.23.0 259 216 * @obsolete Use PhysicsStatistics, IPhysicsStats will be removed in v0.23.0 260 217 */ 261 218 export type IPhysicsStats = PhysicsStatistics; 262 219 263 220 /** 264 264 - * @deprecated Use Drawable, IDrawable will be removed v0.23.0 265 221 * @obsolete Use Drawable, IDrawable will be removed v0.23.0 266 222 */ 267 223 export type IDrawable = Drawable; 268 224 269 225 /** 270 270 - * @deprecated Use Eventable, IEvented will be removed in v0.23.0 271 226 * @obsolete Use Eventable, IEvented will be removed in v0.23.0 272 227 */ 273 228 export type IEvented = Eventable; 274 229 275 230 /** 276 276 - * @deprecated Use NavigatorGamepads, INavigatorGamepads will be removed in v0.23.0 277 231 * @obsolete Use NavigatorGamepads, INavigatorGamepads will be removed in v0.23.0 278 232 */ 279 233 export type INavigatorGamepads = NavigatorGamepads; 280 234 281 235 /** 282 282 - * @deprecated Use NavigatorGamepad, INavigatorGamepad will be removed in v0.23.0 283 236 * @obsolete Use NavigatorGamepad, INavigatorGamepad will be removed in v0.23.0 284 237 */ 285 238 export type INavigatorGamepad = NavigatorGamepad; 286 239 287 240 /** 288 288 - * @deprecated Use GamepadConfiguration, IGamepadConfiguration will be removed in v0.23.0 289 241 * @obsolete Use GamepadConfiguration, IGamepadConfiguration will be removed in v0.23.0 290 242 */ 291 243 export type IGamepadConfiguration = GamepadConfiguration; 292 244 293 245 /** 294 294 - * @deprecated Use ObsoleteOptions, IObsoleteOptions will be removed in v0.23.0 295 246 * @obsolete Use ObsoleteOptions, IObsoleteOptions will be removed in v0.23.0 296 247 */ 297 248 export type IObsoleteOptions = ObsoleteOptions; 298 249 299 250 /** 300 300 - * @deprecated Use PointerEvents, IPointerEvents will be removed in v0.23.0 301 251 * @obsolete Use PointerEvents, IPointerEvents will be removed in v0.23.0 302 252 */ 303 253 export type IPointerEvents = PointerEvents; 304 254 305 255 /** 306 306 - * @deprecated Use Loadable, ILoadable will be removed in v0.23.0 307 256 * @obsolete Use Loadable, ILoadable will be removed in v0.23.0 308 257 */ 309 258 export type ILoadable = Loadable; 310 259 311 260 /** 312 312 - * @deprecated Use CanLoad, ILoader will be removed in v0.23.0 313 261 * @obsolete Use CanLoad, ILoader will be removed in v0.23.0 314 262 */ 315 263 export type ILoader = CanLoad; 316 264 317 265 /** 318 318 - * @deprecated Use CapturePointerConfig, ICapturePointerConfig will be removed in v0.23.0 319 266 * @obsolete Use CapturePointerConfig, ICapturePointerConfig will be removed in v0.23.0 320 267 */ 321 268 export type ICapturePointerConfig = CapturePointerConfig; 322 269 323 270 /** 324 324 - * @deprecated Use PromiseLike, IPromise will be removed in v0.23.0 325 271 * @obsolete Use PromiseLike, IPromise will be removed in v0.23.0 326 272 */ 327 273 export type IPromise<T> = PromiseLike<T>; 328 274 329 275 /** 330 330 - * @deprecated Use SpriteEffect, ISpriteEffect will be removed in v0.23.0 331 276 * @obsolete Use SpriteEffect, ISpriteEffect will be removed in v0.23.0 332 277 */ 333 278 export type ISpriteEffect = SpriteEffect; 334 279 335 280 /** 336 336 - * @deprecated Use SpriteArgs, ISpriteArgs will be removed in v0.23.0 337 281 * @obsolete Use SpriteArgs, ISpriteArgs will be removed in v0.23.0 338 282 */ 339 283 export type ISpriteArgs = SpriteArgs; 340 284 341 285 /** 342 342 - * @deprecated Use SpriteFontArgs, ISpriteFontInitArgs will be removed in v0.23.0 343 286 * @obsolete Use SpriteFontArgs, ISpriteFontInitArgs will be removed in v0.23.0 344 287 */ 345 288 export type ISpriteFontInitArgs = SpriteFontArgs; 346 289 347 290 /** 348 348 - * @deprecated Use SpriteFontOptions, ISpriteFrontOptions will be removed in v0.23.0 349 291 * @obsolete Use SpriteFontOptions, ISpriteFrontOptions will be removed in v0.23.0 350 292 */ 351 293 export type ISpriteFrontOptions = SpriteFontOptions; 352 294 353 295 /** 354 354 - * @deprecated Use TileMapArgs, ITileMapArgs will be removed in v0.23.0 355 296 * @obsolete Use TileMapArgs, ITileMapArgs will be removed in v0.23.0 356 297 */ 357 298 export type ITileMapArgs = TileMapArgs; 358 299 359 300 /** 360 360 - * @deprecated Use TouchEvent, ITouchEvent will be removed in v0.23.0 361 301 * @obsolete Use TouchEvent, ITouchEvent will be removed in v0.23.0 362 302 */ 363 303 export type ITouchEvent = TouchEvent; 364 304 365 305 /** 366 366 - * @deprecated Use Touch, ITouch will be removed in v0.23.0 367 306 * @obsolete Use Touch, ITouch will be removed in v0.23.0 368 307 */ 369 308 export type ITouch = Touch; 370 309 371 310 /** 372 372 - * @deprecated Use TriggerOptions, ITriggerOptions will be removed in v0.23.0 373 311 * @obsolete Use TriggerOptions, ITriggerOptions will be removed in v0.23.0 374 312 */ 375 313 export type ITriggerOptions = TriggerOptions; 376 314 377 315 /** 378 378 - * @deprecated Use ParticleArgs, IParticleArgs will be removed in v0.23.0 379 316 * @obsolete Use ParticleArgs, IParticleArgs will be removed in v0.23.0 380 317 */ 381 318 export type IParticleArgs = ParticleArgs; 382 319 383 320 /** 384 384 - * @deprecated Use ParticleEmitterArgs, IParticleEmitterArgs will be removed in v0.23.0 385 321 * @obsolete Use ParticleEmitterArgs, IParticleEmitterArgs will be removed in v0.23.0 386 322 */ 387 323 export type IParticleEmitterArgs = ParticleEmitterArgs; 388 324 389 325 /** 390 390 - * @deprecated Use PerlinOptions, IPerlinGeneratorOptions will be removed in v0.23.0 391 326 * @obsolete Use PerlinOptions, IPerlinGeneratorOptions will be removed in v0.23.0 392 327 */ 393 328 export type IPerlinGeneratorOptions = PerlinOptions; 394 329 395 330 /** 396 396 - * @deprecated Use PostProcessor, IPostProcessor will be removed in v0.23.0 397 331 * @obsolete Use PostProcessor, IPostProcessor will be removed in v0.23.0 398 332 */ 399 333 export type IPostProcessor = PostProcessor; 400 334 401 335 /** 402 402 - * @deprecated Use LabelArgs, ILabelArgs will be removed in v0.23.0 403 336 * @obsolete Use LabelArgs, ILabelArgs will be removed in v0.23.0 404 337 */ 405 338 export type ILabelArgs = LabelArgs;

+4 -2

src/engine/Docs/Actors.md

Reviewed

··· 215 215 an actor participate, you need to switch from the default [[CollisionType.PreventCollision|prevent collision]] 216 216 to [[CollisionType.Active|active]], [[CollisionType.Fixed|fixed]], or [[CollisionType.Passive|passive]] collision type. 217 217 218 218 + For more information on collisions, please read about [[Physics|rigid body physics]]. 219 219 + 218 220 ```ts 219 221 public Player extends ex.Actor { 220 222 constructor() { 221 223 super(); 222 224 // set preferred CollisionType 223 223 - this.collisionType = ex.CollisionType.Active; 225 225 + this.body.collider.type = ex.CollisionType.Active; 224 226 } 225 227 } 226 228 227 229 // or set the collisionType 228 230 229 231 const actor = new ex.Actor(); 230 230 - actor.collisionType = ex.CollisionType.Active; 232 232 + actor.body.collider.type = ex.CollisionType.Active; 231 233 ``` 232 234 233 235 ## Traits

+37

src/engine/Docs/BoxAndPolygonShape.md

Reviewed

··· 1 1 + ## Box and ConvexPolygon Collision Shapes 2 2 + 3 3 + Excalibur has a [[shape|Shape]] static helper to create boxes and [[polygons|ConvexPolygon]] for collisions in your game. 4 4 + 5 5 + The default shape for a collider is a box, a custom box shape and [[collider|Collider]] can be created for an [[actor|Actor]] [[body|Body]]. The `ex.Shape.Box` helper actually creates a [[ConvexPolygon]] shape in Excalibur. 6 6 + 7 7 + ```typescript 8 8 + const block = new ex.Actor({ 9 9 + pos: new ex.Vector(400, 400), 10 10 + color: ex.Color.Red, 11 11 + body: new ex.Body({ 12 12 + collider: new ex.Collider({ 13 13 + shape: ex.Shape.Box(50, 50) 14 14 + type: ex.CollisionType.Active; 15 15 + }) 16 16 + }) 17 17 + }); 18 18 + ``` 19 19 + 20 20 + Creating a custom [[convex polygon|ConvexPolygon]] shape is just as simple. Excalibur only supports arbitrary convex shapes as a ConvexPolygon, this means no "cavities" in the shape, for example "pac-man" is not a convex shape. 21 21 + 22 22 + The `points` in a [[convex polygon|ConvexPolygon]] have counter-clockwise winding by default, this means the points must be listed in counter-clockwise order around the shape to work. This can be switched by supplying `true` or `false` to the winding argument `ex.Shape.Polygon([...], true)` for clockwise winding. 23 23 + 24 24 + **Keep in mind**, points are defined local to the [[body|Body]] or [[actor|Actor]]. Meaning that the triangle defined below is centered around `ex.Vector(400, 400)` in world space. 25 25 + 26 26 + ```typescript 27 27 + const triangle = new ex.Actor({ 28 28 + pos: new ex.Vector(400, 400), 29 29 + color: ex.Color.Red, 30 30 + body: new ex.Body({ 31 31 + collider: new ex.Collider({ 32 32 + shape: ex.Shape.Polygon([new ex.Vector(0, -100), new ex.Vector(-100, 50), new ex.Vector(100, 50)]) 33 33 + type: ex.CollisionType.Active; 34 34 + }) 35 35 + }) 36 36 + }); 37 37 + ```

+20

src/engine/Docs/CircleShape.md

Reviewed

··· 1 1 + ## Circle Collision Shape 2 2 + 3 3 + Excalibur has a [[shape|Shape]] static helper to create [[circles|Circle]] for collisions in your game. 4 4 + 5 5 + The default shape for a collider is a box, however a custom [[circle|Circle]] shape and [[collider|Collider]] can be created for an [[actor|Actor]] [[body|Body]]. 6 6 + 7 7 + This example creates a circle of `radius = 50`. 8 8 + 9 9 + ```typescript 10 10 + const circle = new ex.Actor({ 11 11 + pos: new ex.Vector(400, 400), 12 12 + color: ex.Color.Red, 13 13 + body: new ex.Body({ 14 14 + collider: new ex.Collider({ 15 15 + shape: ex.Shape.Circle(50) 16 16 + type: ex.CollisionType.Active; 17 17 + }) 18 18 + }) 19 19 + }); 20 20 + ```

+2 -2

src/engine/Docs/Constructors.md

Reviewed

··· 6 6 7 7 ```typescript 8 8 const actor = new ex.Actor(1, 2, 100, 100, ex.Color.Red); 9 9 - actor.collisionType = ex.CollisionType.Active; 9 9 + actor.body.collider.type = ex.CollisionType.Active; 10 10 ``` 11 11 12 12 This is possible: ··· 17 17 width: 100, 18 18 height: 100, 19 19 color: ex.Color.Red, 20 20 - collisionType: ex.CollisionType.Active 21 20 } 22 21 23 22 const actor = new ex.Actor(options); 23 23 + actor.body.collider.type = ex.CollisionType.Active; 24 24 ``` 25 25 26 26 In fact you can create a duplicate this way

+21

src/engine/Docs/EdgeShape.md

Reviewed

··· 1 1 + ## Edge Collision Shape 2 2 + 3 3 + Excalibur has a [[shape|Shape]] static helper to create [[edges|Edge]] for collisions in your game. 4 4 + 5 5 + The default shape for a collider is a box, however a custom [[edge|Edge]] shape and [[collider|Collider]] can be created for an [[actor|Actor]] [[body|Body]]. 6 6 + 7 7 + [[Edges|Edge]] are useful for creating walls, barriers, or platforms in your game. 8 8 + 9 9 + **Keep in mind**, edges are defined local to the [[body|Body]] or [[actor|Actor]]. Meaning that the edge defined below starts at `ex.Vector(100, 100)` and goes to `ex.Vector(130, 400)` in world space. It is recommended when defining edges to leave the first coordinate `ex.Vector.Zero` to avoid confusion. 10 10 + 11 11 + ```typescript 12 12 + const wall = new ex.Actor({ 13 13 + pos: new ex.Vector(100, 300), 14 14 + color: ex.Color.Blue, 15 15 + body: new ex.Body({ 16 16 + collider: new ex.Collider({ 17 17 + shape: ex.Shape.Edge(new ex.Vector.Zero(), new ex.Vector(30, 100)) 18 18 + }) 19 19 + }) 20 20 + }); 21 21 + ```

+2 -2

src/engine/Docs/Labels.md

Reviewed

··· 11 11 var label = new ex.Label('Hello World', 50, 50, '10px Arial'); 12 12 // properties 13 13 var label = new ex.Label(); 14 14 - label.x = 50; 15 15 - label.y = 50; 14 14 + label.pos.x = 50; 15 15 + label.pos.y = 50; 16 16 label.fontFamily = 'Arial'; 17 17 label.fontSize = 10; 18 18 label.fontUnit = ex.FontUnit.Px; // pixels are the default

+112 -17

src/engine/Docs/Physics.md

Reviewed

··· 2 2 simple axis-aligned way of doing basic collision detection for non-rotated rectangular areas, defined by an actor's 3 3 [[BoundingBox|bounding box]]. 4 4 5 5 + ## Physics hierarchy 6 6 + 7 7 + Excalibur physics are organized into a hierarchy, each has a specific single role in the collision system. 8 8 + 9 9 + ``` 10 10 + Actor (game entity) 11 11 + -> Body (transform infomation) 12 12 + -> Collider (collision related information) 13 13 + -> Shape (geometry for collision) 14 14 + ``` 15 15 + 16 16 + For example: 17 17 + 18 18 + ```typescript 19 19 + const actor = new ex.Actor({ 20 20 + pos: new ex.Vector(100, 100), 21 21 + body: new ex.Body({ 22 22 + vel: new ex.Vector(20, 0), // velocity 23 23 + acc: new ex.Vector(0, 100), // acceleration 24 24 + collider: new ex.Collider({ 25 25 + mass: 100, // mass of 100 26 26 + type: ex.CollisionType.Active, // active collision type 27 27 + shape: ex.Shape.Circle(50) // circle geometry of radius 50 28 28 + }) 29 29 + }) 30 30 + }); 31 31 + ``` 32 32 + 33 33 + ### Actor/Body 34 34 + 35 35 + Actor's have position, velocity, and acceleration in physical space, all of these positional physical attributes are contained inside the [[Body]]. Only 1 actor can be associated with a [[Body]]. 36 36 + 37 37 + **[[Body]]** is the container for all transform related information for physics and any associated colliders. 38 38 + 39 39 + This looks like this: 40 40 + 41 41 + ```typescript 42 42 + const actor = new ex.Actor({ 43 43 + // actor's position is stored on a default body 44 44 + pos: new ex.Vector(40, 40); 45 45 + }); 46 46 + 47 47 + // actor position is stored on the body, actor.pos is a convenience 48 48 + actor.pos === actor.body.pos 49 49 + 50 50 + // actor velocity is stored on the body, actor.vel is a convenience 51 51 + actor.vel === actor.body.vel 52 52 + 53 53 + // actor acceleration is stored on the body, actor.acc is a convenience 54 54 + actor.acc === actor.body.acc 55 55 + ``` 56 56 + 57 57 + ### Collider 58 58 + 59 59 + [[Body]]'s have a default box collider that is derived from the width and height of the [[Actor]] associated. Only 1 [[Collider]] can be associated with a [[Body]], and by extension an [[Actor]]. (Collision events are re-emitted onto [[Actor]]) 60 60 + 61 61 + **[[Collider]]** is the container of all collision related information, collision type, collision events, mass, inertia, friction, bounciness, shape, etc. 62 62 + 63 63 + ### Shape 64 64 + 65 65 + [[Collider]]'s have [[CollisionShape]]'s that represent physical geometry. The possible shapes in Excalibur are [[Circle]], [[Edge]], and [[ConvexPolygon]]. A collider can only have 1 [[CollisionShape]] associated with them at a time. 66 66 + 5 67 ## Collision Types 6 68 7 7 - Actors have the default collision type of [[CollisionType.PreventCollision]], this is so actors don't accidentally opt into something computationally expensive. **In order for actors to participate in collisions** and the global physics system, actors **must** have a collision type of [[CollisionType.Active]] or [[CollisionType.Fixed]]. 69 69 + Colliders have the default collision type of [[CollisionType.PreventCollision]], this is so colliders don't accidentally opt into something computationally expensive. **In order for colliders to participate in collisions** and the global physics system, colliders **must** have a collision type of [[CollisionType.Active]] or [[CollisionType.Fixed]]. 8 70 9 71 ### Prevent 10 72 ··· 52 114 To enable physics in your game it is as simple as setting [[Physics.enabled]] to true and picking your 53 115 [[CollisionResolutionStrategy]] 54 116 55 55 - Excalibur supports 3 different types of collision area shapes in its physics simulation: [[PolygonArea|polygons]], 56 56 - [[CircleArea|circles]], and [[EdgeArea|edges]]. To use any one of these areas on an actor there are convenience methods off of 57 57 - the [[Actor|actor]] [[Body|physics body]]: [[Body.useBoxCollision|useBoxCollision]], 58 58 - [[Body.usePolygonCollision|usePolygonCollision]], [[Body.useCircleCollision|useCircleCollision]], and [[Body.useEdgeCollision]] 117 117 + Excalibur supports 3 different types of collision area shapes in its physics simulation: [[ConvexPolygon|polygons]], 118 118 + [[Circle|circles]], and [[Edge|edges]]. To use any one of these areas on an actor there are convenience methods off of 119 119 + the [[Actor|actor]] [[Body|physics body]]: [[Body.useBoxCollider|useBoxCollider]], 120 120 + [[Body.usePolygonCollider|usePolygonCollider]], [[Body.useCircleCollider|useCircleCollider]], and [[Body.useEdgeCollider]] 59 121 60 122 ## Collision Event Lifecycle 61 123 ··· 69 131 70 132 ```typescript 71 133 actor.on('collisionstart', () => {...}) 134 134 + // or 135 135 + actor.body.collider.on('collisionstart', () => {...}) 72 136 ``` 73 137 74 138 ### Collision End "collisionend" ··· 79 143 80 144 ```typescript 81 145 actor.on('collisionend', () => {...}) 146 146 + // or 147 147 + actor.body.collider.on('collisionend', () => {...}) 82 148 ``` 83 149 84 150 ### Pre Collision "precollision" 85 151 86 152 The **precollision** event is fired **every frame** where a collision pair is found and two bodies are intersecting. 87 153 88 88 - This event is useful for building in custom collision resolution logic in Passive-Passive or Active-Passive scenarios. For example in a breakout game you may want to tweak the angle of richochet of the ball depending on which side of the paddle you hit. 154 154 + This event is useful for building in custom collision resolution logic in Passive-Passive or Active-Passive scenarios. For example in a breakout game you may want to tweak the angle of ricochet of the ball depending on which side of the paddle you hit. 89 155 90 156 ```typescript 91 157 actor.on('precollision', () => {...}) 158 158 + // or 159 159 + actor.body.collider.on('precollision', () => {...}) 92 160 ``` 93 161 94 162 ### Post Collision "postcollision" ··· 99 167 100 168 ```typescript 101 169 actor.on('postcollision', () => {...}) 170 170 + // or 171 171 + actor.body.collider.on('postcollision', () => {...}) 102 172 ``` 103 173 104 174 ## Example Active-Active/Active-Fixed scenario ··· 115 185 ex.Physics.acc.setTo(0, 700); 116 186 117 187 const block = new ex.Actor({ 118 118 - x: 300, 119 119 - y: 0, 188 188 + pos: new ex.Vector(300, 0), 120 189 width: 20, 121 190 height: 20, 122 122 - color: ex.Color.Blue.clone(), 123 123 - collisionType: ex.CollisionType.Active 191 191 + color: ex.Color.Blue 124 192 }); 125 125 - block.body.useBoxCollision(); // useBoxCollision is the default, technically optional 193 193 + block.body.useBoxCollider(); // useBoxCollision is the default, technically optional 194 194 + block.body.collider.type = ex.CollisionType.Active; 126 195 game.add(block); 127 196 197 197 + // or 198 198 + 199 199 + const block = new ex.Actor({ 200 200 + pos: new ex.Vector(300, 0), 201 201 + color: ex.Color.Blue, 202 202 + body: new ex.Body({ 203 203 + collider: new ex.Collider({ 204 204 + type: ex.CollisionType.Active, 205 205 + shape: ex.Shape.Box(20, 20) 206 206 + }) 207 207 + }) 208 208 + }); 209 209 + 128 210 const circle = new ex.Actor({ 129 211 x: 301, 130 212 y: 100, 131 213 width: 20, 132 214 height: 20, 133 133 - color: ex.Color.Red.clone(), 134 134 - collisionType: ex.CollisionType.Active 215 215 + color: ex.Color.Red 135 216 }); 136 136 - circle.body.useCircleCollision(10); 217 217 + circle.body.useCircleCollider(10); 218 218 + circle.body.collider.type = ex.CollisionType.Active; 137 219 game.add(circle); 138 220 221 221 + // or 222 222 + 223 223 + const circle = new ex.Actor({ 224 224 + pos: new ex.Vector(301, 100), 225 225 + color: ex.Color.Red, 226 226 + body: new ex.Body({ 227 227 + collider: new ex.Collider({ 228 228 + shape: ex.Shape.Circle(10), 229 229 + type: ex.CollisionType.Active 230 230 + }) 231 231 + }) 232 232 + }); 233 233 + 139 234 const ground = new ex.Actor({ 140 235 x: 300, 141 236 y: 380, 142 237 width: 600, 143 238 height: 10, 144 144 - color: ex.Color.Black.clone(), 145 145 - collisionType: ex.CollisionType.Fixed 239 239 + color: ex.Color.Black; 146 240 }); 147 241 148 148 - ground.body.useBoxCollision(); // optional 242 242 + ground.body.useBoxCollider(); // optional 243 243 + groundbody.collider.type = ex.CollisionType.Fixed; 149 244 150 245 game.add(ground); 151 246 // start the game

+1 -1

src/engine/Docs/Triggers.md

Reviewed

··· 27 27 var actor = new ex.Actor(100, 0, 40, 40, ex.Color.Red); 28 28 29 29 // Enable collision on actor (else trigger won't fire) 30 30 - actor.collisionType = ex.CollisionType.Active; 30 30 + actor.body.collider.type = ex.CollisionType.Active; 31 31 32 32 // tell the actor to move across the trigger with a velocity of 100 33 33 actor.actions.moveTo(100, 200, 100);

+18 -10

src/engine/EventDispatcher.ts

Reviewed

··· 10 10 * 11 11 * [[include:Events.md]] 12 12 */ 13 13 - export class EventDispatcher implements Eventable { 14 14 - private _handlers: { [key: string]: { (event: GameEvent<any>): void }[] } = {}; 15 15 - private _wiredEventDispatchers: EventDispatcher[] = []; 13 13 + export class EventDispatcher<T = any> implements Eventable { 14 14 + private _handlers: { [key: string]: { (event: GameEvent<T>): void }[] } = {}; 15 15 + private _wiredEventDispatchers: Eventable[] = []; 16 16 17 17 - private _target: any; 17 17 + private _target: T; 18 18 19 19 /** 20 20 * @param target The object that will be the recipient of events from this event dispatcher 21 21 */ 22 22 - constructor(target: any) { 22 22 + constructor(target: T) { 23 23 this._target = target; 24 24 } 25 25 26 26 /** 27 27 + * Clears any existing handlers or wired event dispatchers on this event dispatcher 28 28 + */ 29 29 + public clear() { 30 30 + this._handlers = {}; 31 31 + this._wiredEventDispatchers = []; 32 32 + } 33 33 + 34 34 + /** 27 35 * Emits an event for target 28 36 * @param eventName The name of the event to publish 29 37 * @param event Optionally pass an event data object to the handler 30 38 */ 31 31 - public emit(eventName: string, event: GameEvent<any>) { 39 39 + public emit(eventName: string, event: GameEvent<T>) { 32 40 if (!eventName) { 33 41 // key not mapped 34 42 return; ··· 64 72 * @param eventName The name of the event to subscribe to 65 73 * @param handler The handler callback to fire on this event 66 74 */ 67 67 - public on(eventName: string, handler: (event: GameEvent<any>) => void) { 75 75 + public on(eventName: string, handler: (event: GameEvent<T>) => void) { 68 76 eventName = eventName.toLowerCase(); 69 77 if (!this._handlers[eventName]) { 70 78 this._handlers[eventName] = []; ··· 86 94 * @param handler Optionally the specific handler to unsubscribe 87 95 * 88 96 */ 89 89 - public off(eventName: string, handler?: (event: GameEvent<any>) => void) { 97 97 + public off(eventName: string, handler?: (event: GameEvent<T>) => void) { 90 98 eventName = eventName.toLowerCase(); 91 99 const eventHandlers = this._handlers[eventName]; 92 100 ··· 111 119 * @param eventName The name of the event to subscribe to once 112 120 * @param handler The handler of the event that will be auto unsubscribed 113 121 */ 114 114 - public once(eventName: string, handler: (event: GameEvent<any>) => void) { 115 115 - const metaHandler = (event: GameEvent<any>) => { 122 122 + public once(eventName: string, handler: (event: GameEvent<T>) => void) { 123 123 + const metaHandler = (event: GameEvent<T>) => { 116 124 const ev = event || new GameEvent(); 117 125 ev.target = ev.target || this._target; 118 126

+51 -9

src/engine/Events.ts

Reviewed

··· 8 8 import { Side } from './Collision/Side'; 9 9 import * as Input from './Input/Index'; 10 10 import { Pair, Camera } from './index'; 11 11 + import { Collider } from './Collision/Collider'; 11 12 12 13 export enum EventTypes { 13 14 Kill = 'kill', ··· 158 159 * some events are unique to a type, others are not. 159 160 * 160 161 */ 161 161 - export class GameEvent<T> { 162 162 + export class GameEvent<T, U = T> { 162 163 /** 163 164 * Target object for this event. 164 165 */ 165 166 public target: T; 167 167 + 168 168 + /** 169 169 + * Other target object for this event 170 170 + */ 171 171 + public other: U | null; 172 172 + 166 173 /** 167 174 * determines, if event bubbles to the target's ancestors 168 175 */ ··· 443 450 /** 444 451 * Event thrown on an [[Actor|actor]] when a collision will occur this frame if it resolves 445 452 */ 446 446 - export class PreCollisionEvent extends GameEvent<Actor> { 453 453 + export class PreCollisionEvent<T extends Collider | Actor = Actor> extends GameEvent<T> { 447 454 /** 448 455 * @param actor The actor the event was thrown on 449 456 * @param other The actor that will collided with the current actor 450 457 * @param side The side that will be collided with the current actor 451 458 * @param intersection Intersection vector 452 459 */ 453 453 - constructor(public actor: Actor, public other: Actor, public side: Side, public intersection: Vector) { 460 460 + constructor(actor: T, public other: T, public side: Side, public intersection: Vector) { 454 461 super(); 455 462 this.target = actor; 456 463 } 464 464 + 465 465 + public get actor() { 466 466 + return this.target; 467 467 + } 468 468 + 469 469 + public set actor(actor: T) { 470 470 + this.target = actor; 471 471 + } 457 472 } 458 473 459 474 /** 460 475 * Event thrown on an [[Actor|actor]] when a collision has been resolved (body reacted) this frame 461 476 */ 462 462 - export class PostCollisionEvent extends GameEvent<Actor> { 477 477 + export class PostCollisionEvent<T extends Collider | Actor = Actor> extends GameEvent<T> { 463 478 /** 464 479 * @param actor The actor the event was thrown on 465 480 * @param other The actor that did collide with the current actor 466 481 * @param side The side that did collide with the current actor 467 482 * @param intersection Intersection vector 468 483 */ 469 469 - constructor(public actor: Actor, public other: Actor, public side: Side, public intersection: Vector) { 484 484 + constructor(actor: T, public other: T, public side: Side, public intersection: Vector) { 470 485 super(); 471 486 this.target = actor; 472 487 } 488 488 + 489 489 + public get actor() { 490 490 + return this.target; 491 491 + } 492 492 + 493 493 + public set actor(actor: T) { 494 494 + this.target = actor; 495 495 + } 473 496 } 474 497 475 498 /** 476 499 * Event thrown the first time an [[Actor|actor]] collides with another, after an actor is in contact normal collision events are fired. 477 500 */ 478 478 - export class CollisionStartEvent extends GameEvent<Actor> { 501 501 + export class CollisionStartEvent<T extends Collider | Actor = Actor> extends GameEvent<T> { 479 502 /** 480 503 * 504 504 + * @param actor 505 505 + * @param other 506 506 + * @param pair 481 507 */ 482 482 - constructor(public actor: Actor, public other: Actor, public pair: Pair) { 508 508 + constructor(actor: T, public other: T, public pair: Pair) { 483 509 super(); 510 510 + this.target = actor; 511 511 + } 512 512 + 513 513 + public get actor() { 514 514 + return this.target; 515 515 + } 516 516 + 517 517 + public set actor(actor: T) { 484 518 this.target = actor; 485 519 } 486 520 } ··· 488 522 /** 489 523 * Event thrown when the [[Actor|actor]] is no longer colliding with another 490 524 */ 491 491 - export class CollisionEndEvent extends GameEvent<Actor> { 525 525 + export class CollisionEndEvent<T extends Collider | Actor = Actor> extends GameEvent<T> { 492 526 /** 493 527 * 494 528 */ 495 495 - constructor(public actor: Actor, public other: Actor) { 529 529 + constructor(actor: T, public other: T) { 496 530 super(); 531 531 + this.target = actor; 532 532 + } 533 533 + 534 534 + public get actor() { 535 535 + return this.target; 536 536 + } 537 537 + 538 538 + public set actor(actor: T) { 497 539 this.target = actor; 498 540 } 499 541 }

+3

src/engine/Interfaces/Clonable.ts

Reviewed

··· 1 1 + export interface Clonable<T> { 2 2 + clone(): T; 3 3 + }

+3 -2

src/engine/Label.ts

Reviewed

··· 1 1 import { Engine } from './Engine'; 2 2 import { Color } from './Drawing/Color'; 3 3 import { SpriteFont } from './Drawing/SpriteSheet'; 4 4 - import { Actor, CollisionType } from './Actor'; 4 4 + import { Actor } from './Actor'; 5 5 import { Configurable } from './Configurable'; 6 6 import { Vector } from './Algebra'; 7 7 + import { CollisionType } from './Collision/CollisionType'; 7 8 /** 8 9 * Enum representing the different font size units 9 10 * https://developer.mozilla.org/en-US/docs/Web/CSS/font-size ··· 219 220 this.text = text || ''; 220 221 this.color = Color.Black; 221 222 this.spriteFont = spriteFont; 222 222 - this.collisionType = CollisionType.PreventCollision; 223 223 + this.body.collider.type = CollisionType.PreventCollision; 223 224 this.fontFamily = fontFamily || 'sans-serif'; // coalesce to default canvas font 224 225 225 226 this._textShadowOn = false;

+6 -5

src/engine/Particles.ts

Reviewed

··· 1 1 import { Engine } from './Engine'; 2 2 - import { Actor, CollisionType } from './Actor'; 2 2 + import { Actor } from './Actor'; 3 3 import { Sprite } from './Drawing/Sprite'; 4 4 import { Color } from './Drawing/Color'; 5 5 import { Vector } from './Algebra'; ··· 8 8 import * as Traits from './Traits/Index'; 9 9 import { Configurable } from './Configurable'; 10 10 import { Random } from './Math/Random'; 11 11 + import { CollisionType } from './Collision/CollisionType'; 11 12 12 13 /** 13 14 * An enum that represents the types of emitter nozzles ··· 355 356 constructor(xOrConfig?: number | ParticleEmitterArgs, y?: number, width?: number, height?: number) { 356 357 super(typeof xOrConfig === 'number' ? { x: xOrConfig, y: y, width: width, height: height } : xOrConfig); 357 358 this._particlesToEmit = 0; 358 358 - this.collisionType = CollisionType.PreventCollision; 359 359 + this.body.collider.type = CollisionType.PreventCollision; 359 360 this.particles = new Util.Collection<Particle>(); 360 361 this.deadParticles = new Util.Collection<Particle>(); 361 362 this.random = new Random(); ··· 399 400 const dy = vel * Math.sin(angle); 400 401 401 402 if (this.emitterType === EmitterType.Rectangle) { 402 402 - ranX = Util.randomInRange(this.pos.x, this.pos.x + this.getWidth(), this.random); 403 403 - ranY = Util.randomInRange(this.pos.y, this.pos.y + this.getHeight(), this.random); 403 403 + ranX = Util.randomInRange(this.pos.x, this.pos.x + this.width, this.random); 404 404 + ranY = Util.randomInRange(this.pos.y, this.pos.y + this.height, this.random); 404 405 } else if (this.emitterType === EmitterType.Circle) { 405 406 const radius = Util.randomInRange(0, this.radius, this.random); 406 407 ranX = radius * Math.cos(angle) + this.pos.x; ··· 465 466 466 467 if (this.focus) { 467 468 ctx.fillRect(this.focus.x + this.pos.x, this.focus.y + this.pos.y, 3, 3); 468 468 - DrawUtil.line(ctx, Color.Yellow, this.focus.x + this.pos.x, this.focus.y + this.pos.y, super.getCenter().x, super.getCenter().y); 469 469 + DrawUtil.line(ctx, Color.Yellow, this.focus.x + this.pos.x, this.focus.y + this.pos.y, this.center.x, this.center.y); 469 470 ctx.fillText('Focus', this.focus.x + this.pos.x, this.focus.y + this.pos.y); 470 471 } 471 472 }

+9 -2

src/engine/Scene.ts

Reviewed

··· 28 28 import * as Events from './Events'; 29 29 import * as ActorUtils from './Util/Actors'; 30 30 import { Trigger } from './Trigger'; 31 31 + import { Body } from './Collision/Body'; 31 32 /** 32 33 * [[Actor|Actors]] are composed together into groupings called Scenes in 33 34 * Excalibur. The metaphor models the same idea behind real world ··· 47 48 * The actors in the current scene 48 49 */ 49 50 public actors: Actor[] = []; 51 51 + 52 52 + /** 53 53 + * Physics bodies in the current scene 54 54 + */ 55 55 + private _bodies: Body[] = []; 50 56 51 57 /** 52 58 * The triggers in the current scene ··· 342 348 // Cycle through actors updating actors 343 349 for (i = 0, len = this.actors.length; i < len; i++) { 344 350 this.actors[i].update(engine, delta); 351 351 + this._bodies[i] = this.actors[i].body; 345 352 } 346 353 347 354 // Cycle through triggers updating ··· 357 364 // Run the broadphase and narrowphase 358 365 if (this._broadphase && Physics.enabled) { 359 366 const beforeBroadphase = Date.now(); 360 360 - this._broadphase.update(this.actors, delta); 361 361 - let pairs = this._broadphase.broadphase(this.actors, delta, engine.stats.currFrame); 367 367 + this._broadphase.update(this._bodies, delta); 368 368 + let pairs = this._broadphase.broadphase(this._bodies, delta, engine.stats.currFrame); 362 369 const afterBroadphase = Date.now(); 363 370 364 371 const beforeNarrowphase = Date.now();

+20 -7

src/engine/TileMap.ts

Reviewed

··· 8 8 import { SpriteSheet } from './Drawing/SpriteSheet'; 9 9 import * as Events from './Events'; 10 10 import { Configurable } from './Configurable'; 11 11 + import { obsolete } from './Util/Decorators'; 11 12 12 13 /** 13 14 * @hidden ··· 82 83 * is no collision null is returned. 83 84 */ 84 85 public collides(actor: Actor): Vector { 85 85 - const width = actor.pos.x + actor.getWidth(); 86 86 - const height = actor.pos.y + actor.getHeight(); 87 87 - const actorBounds = actor.getBounds(); 86 86 + const width = actor.pos.x + actor.width; 87 87 + const height = actor.pos.y + actor.height; 88 88 + const actorBounds = actor.body.collider.bounds; 88 89 const overlaps: Vector[] = []; 89 90 // trace points for overlap 90 90 - for (let x = actorBounds.left; x <= width; x += Math.min(actor.getWidth() / 2, this.cellWidth / 2)) { 91 91 - for (let y = actorBounds.top; y <= height; y += Math.min(actor.getHeight() / 2, this.cellHeight / 2)) { 91 91 + for (let x = actorBounds.left; x <= width; x += Math.min(actor.width / 2, this.cellWidth / 2)) { 92 92 + for (let y = actorBounds.top; y <= height; y += Math.min(actor.height / 2, this.cellHeight / 2)) { 92 93 const cell = this.getCellByPoint(x, y); 93 94 if (cell && cell.solid) { 94 94 - const overlap = actorBounds.collides(cell.getBounds()); 95 95 - const dir = actor.getCenter().sub(cell.getCenter()); 95 95 + const overlap = actorBounds.intersect(cell.bounds); 96 96 + const dir = actor.center.sub(cell.center); 96 97 if (overlap && overlap.dot(dir) > 0) { 97 98 overlaps.push(overlap); 98 99 } ··· 343 344 /** 344 345 * Returns the bounding box for this cell 345 346 */ 347 347 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'BoundingBox.bounds' }) 346 348 public getBounds() { 347 349 return this._bounds; 348 350 } 351 351 + 352 352 + public get bounds() { 353 353 + return this._bounds; 354 354 + } 355 355 + 349 356 /** 350 357 * Gets the center coordinate of this cell 351 358 */ 359 359 + @obsolete({ message: 'Will be removed in v0.24.0', alternateMethod: 'BoundingBox.center' }) 352 360 public getCenter(): Vector { 353 361 return new Vector(this.x + this.width / 2, this.y + this.height / 2); 354 362 } 363 363 + 364 364 + public get center(): Vector { 365 365 + return new Vector(this.x + this.width / 2, this.y + this.height / 2); 366 366 + } 367 367 + 355 368 /** 356 369 * Add another [[TileSprite]] to this cell 357 370 */

-28

src/engine/Traits/EulerMovement.ts

Reviewed

··· 1 1 - import { Physics } from './../Physics'; 2 2 - import { Trait } from '../Interfaces/Trait'; 3 3 - import { Actor, CollisionType } from '../Actor'; 4 4 - import { Engine } from '../Engine'; 5 5 - 6 6 - export class EulerMovement implements Trait { 7 7 - public update(actor: Actor, _engine: Engine, delta: number) { 8 8 - // Update placements based on linear algebra 9 9 - const seconds = delta / 1000; 10 10 - 11 11 - const totalAcc = actor.acc.clone(); 12 12 - // Only active vanilla actors are affected by global acceleration 13 13 - if (actor.collisionType === CollisionType.Active) { 14 14 - totalAcc.addEqual(Physics.acc); 15 15 - } 16 16 - 17 17 - actor.oldVel = actor.vel; 18 18 - actor.vel.addEqual(totalAcc.scale(seconds)); 19 19 - 20 20 - actor.pos.addEqual(actor.vel.scale(seconds)).addEqual(totalAcc.scale(0.5 * seconds * seconds)); 21 21 - 22 22 - actor.rx += actor.torque * (1.0 / actor.moi) * seconds; 23 23 - actor.rotation += actor.rx * seconds; 24 24 - 25 25 - actor.scale.x += (actor.sx * delta) / 1000; 26 26 - actor.scale.y += (actor.sy * delta) / 1000; 27 27 - } 28 28 - }

-1

src/engine/Traits/Index.ts

Reviewed

··· 1 1 export * from './CapturePointer'; 2 2 - export * from './EulerMovement'; 3 2 export * from './OffscreenCulling'; 4 3 export * from './TileMapCollisionDetection';

+1 -1

src/engine/Traits/OffscreenCulling.ts

Reviewed

··· 17 17 18 18 let actorBoundsOffscreen = false; 19 19 if (engine && engine.currentScene && engine.currentScene.camera && engine.currentScene.camera.viewport) { 20 20 - actorBoundsOffscreen = !engine.currentScene.camera.viewport.collides(actor.getBounds(true)); 20 20 + actorBoundsOffscreen = !engine.currentScene.camera.viewport.intersect(actor.body.collider.bounds); 21 21 } 22 22 23 23 if (!actor.isOffScreen) {

+6 -4

src/engine/Traits/TileMapCollisionDetection.ts

Reviewed

··· 1 1 import { Trait } from '../Interfaces/Trait'; 2 2 - import { Actor, CollisionType } from '../Actor'; 2 2 + import { Actor } from '../Actor'; 3 3 import { Engine } from '../Engine'; 4 4 import { Vector } from '../Algebra'; 5 5 import { Side } from '../Collision/Side'; 6 6 import { PreCollisionEvent, PostCollisionEvent } from '../Events'; 7 7 + import { CollisionType } from '../Collision/CollisionType'; 8 8 + import { BoundingBox } from '../Collision/Index'; 7 9 8 10 export class TileMapCollisionDetection implements Trait { 9 11 public update(actor: Actor, engine: Engine) { 10 12 const eventDispatcher = actor.eventDispatcher; 11 11 - if (actor.collisionType !== CollisionType.PreventCollision && engine.currentScene && engine.currentScene.tileMaps) { 13 13 + if (actor.body.collider.type !== CollisionType.PreventCollision && engine.currentScene && engine.currentScene.tileMaps) { 12 14 for (let j = 0; j < engine.currentScene.tileMaps.length; j++) { 13 15 const map = engine.currentScene.tileMaps[j]; 14 16 let intersectMap: Vector; ··· 18 20 if (max-- < 0) { 19 21 break; 20 22 } 21 21 - side = actor.getSideFromIntersect(intersectMap); 23 23 + side = BoundingBox.getSideFromIntersection(intersectMap); 22 24 eventDispatcher.emit('precollision', new PreCollisionEvent(actor, null, side, intersectMap)); 23 23 - if (actor.collisionType === CollisionType.Active) { 25 25 + if (actor.body.collider.type === CollisionType.Active) { 24 26 actor.pos.y += intersectMap.y; 25 27 actor.pos.x += intersectMap.x; 26 28 eventDispatcher.emit('postcollision', new PostCollisionEvent(actor, null, side, intersectMap));

+8 -7

src/engine/Trigger.ts

Reviewed

··· 2 2 import { Engine } from './Engine'; 3 3 import { ActionQueue } from './Actions/Action'; 4 4 import { EventDispatcher } from './EventDispatcher'; 5 5 - import { Actor, CollisionType } from './Actor'; 5 5 + import { Actor, isActor } from './Actor'; 6 6 import { Vector } from './Algebra'; 7 7 import { ExitTriggerEvent, EnterTriggerEvent, CollisionEndEvent, CollisionStartEvent } from './Events'; 8 8 import * as Util from './Util/Util'; 9 9 + import { CollisionType } from './Collision/CollisionType'; 9 10 10 11 /** 11 12 * ITriggerOptions ··· 82 83 } 83 84 84 85 this.visible = opts.visible; 85 85 - this.collisionType = CollisionType.Passive; 86 86 + this.body.collider.type = CollisionType.Passive; 86 87 this.eventDispatcher = new EventDispatcher(this); 87 88 this.actionQueue = new ActionQueue(this); 88 89 89 89 - this.on('collisionstart', (evt: CollisionStartEvent) => { 90 90 - if (this.filter(evt.other)) { 90 90 + this.on('collisionstart', (evt: CollisionStartEvent<Actor>) => { 91 91 + if (isActor(evt.other) && this.filter(evt.other)) { 91 92 this.emit('enter', new EnterTriggerEvent(this, evt.other)); 92 93 this._dispatchAction(); 93 94 // remove trigger if its done, -1 repeat forever ··· 97 98 } 98 99 }); 99 100 100 100 - this.on('collisionend', (evt: CollisionEndEvent) => { 101 101 - if (this.filter(evt.other)) { 101 101 + this.on('collisionend', (evt: CollisionEndEvent<Actor>) => { 102 102 + if (isActor(evt.other) && this.filter(evt.other)) { 102 103 this.emit('exit', new ExitTriggerEvent(this, evt.other)); 103 104 } 104 105 }); ··· 129 130 ctx.save(); 130 131 ctx.translate(this.pos.x, this.pos.y); 131 132 132 132 - const bb = this.getBounds(); 133 133 + const bb = this.body.collider.bounds; 133 134 const wp = this.getWorldPos(); 134 135 bb.left = bb.left - wp.x; 135 136 bb.right = bb.right - wp.x;

+5 -2

src/engine/UIActor.ts

Reviewed

··· 1 1 import { Vector } from './Algebra'; 2 2 import { Engine } from './Engine'; 3 3 - import { Actor, ActorArgs, CollisionType } from './Actor'; 3 3 + import { Actor, ActorArgs } from './Actor'; 4 4 import * as Traits from './Traits/Index'; 5 5 + import { CollisionType } from './Collision/CollisionType'; 6 6 + import { Shape } from './Collision/Shape'; 5 7 6 8 /** 7 9 * Helper [[Actor]] primitive for drawing UI's, optimized for UI drawing. Does ··· 28 30 this.traits = []; 29 31 this.traits.push(new Traits.CapturePointer()); 30 32 this.anchor.setTo(0, 0); 31 31 - this.collisionType = CollisionType.PreventCollision; 33 33 + this.body.collider.type = CollisionType.PreventCollision; 34 34 + this.body.collider.shape = Shape.Box(this.width, this.height, this.anchor); 32 35 this.enableCapturePointer = true; 33 36 } 34 37

+1 -1

src/engine/Util/CullingBox.ts

Reviewed

··· 25 25 const drawingWidth = actor.currentDrawing.drawWidth; 26 26 const drawingHeight = actor.currentDrawing.drawHeight; 27 27 const rotation = actor.rotation; 28 28 - const anchor = actor.getCenter(); 28 28 + const anchor = actor.center; 29 29 const worldPos = actor.getWorldPos(); 30 30 31 31 this._topLeft.x = worldPos.x - drawingWidth / 2;

+15

src/engine/Util/Decorators.ts

Reviewed

··· 37 37 const constructor = function() { 38 38 const args = Array.prototype.slice.call(arguments); 39 39 Logger.getInstance().warn(message); 40 40 + // tslint:disable-next-line: no-console 41 41 + if (console.trace) { 42 42 + // tslint:disable-next-line: no-console 43 43 + console.trace(); 44 44 + } 40 45 return new method(...args); 41 46 }; 42 47 constructor.prototype = method.prototype; ··· 46 51 if (descriptor && descriptor.value) { 47 52 method.value = function(this: any) { 48 53 Logger.getInstance().warn(message); 54 54 + // tslint:disable-next-line: no-console 55 55 + if (console.trace) { 56 56 + // tslint:disable-next-line: no-console 57 57 + console.trace(); 58 58 + } 49 59 return descriptor.value.apply(this, arguments); 50 60 }; 51 61 return method; ··· 54 64 if (descriptor && descriptor.get) { 55 65 method.get = function(this: any) { 56 66 Logger.getInstance().warn(message); 67 67 + // tslint:disable-next-line: no-console 68 68 + if (console.trace) { 69 69 + // tslint:disable-next-line: no-console 70 70 + console.trace(); 71 71 + } 57 72 return descriptor.get.apply(this, arguments); 58 73 }; 59 74 }

+11

src/engine/Util/Util.ts

Reviewed

··· 236 236 return Side.None; 237 237 } 238 238 239 239 + /** 240 240 + * @obsolete use Util.getSideFromDirection 241 241 + */ 239 242 export function getSideFromVector(direction: Vector) { 243 243 + return getSideFromDirection(direction); 244 244 + } 245 245 + 246 246 + /** 247 247 + * Returns the side in the direction of the vector supplied 248 248 + * @param direction Vector to check 249 249 + */ 250 250 + export function getSideFromDirection(direction: Vector) { 240 251 const directions = [Vector.Left, Vector.Right, Vector.Up, Vector.Down]; 241 252 const directionEnum = [Side.Left, Side.Right, Side.Top, Side.Bottom]; 242 253

+2 -1

src/engine/index.ts

Reviewed

··· 10 10 // that will be exposed as the `ex` global variable. 11 11 12 12 export * from './Engine'; 13 13 - export { Actor, ActorArgs as IActorArgs, CollisionType } from './Actor'; 13 13 + export { Actor, ActorArgs as IActorArgs } from './Actor'; 14 14 + export { CollisionType } from './Collision/CollisionType'; 14 15 export * from './Algebra'; 15 16 export * from './Camera'; 16 17 export * from './Class';

+92 -96

src/spec/ActorSpec.ts

Reviewed

··· 14 14 jasmine.addMatchers(ExcaliburMatchers); 15 15 engine = TestUtils.engine({ width: 100, height: 100 }); 16 16 actor = new ex.Actor(); 17 17 - actor.collisionType = ex.CollisionType.Active; 17 17 + actor.body.collider.type = ex.CollisionType.Active; 18 18 scene = new ex.Scene(engine); 19 19 engine.currentScene = scene; 20 20 ··· 55 55 rotation: 2, 56 56 rx: 0.1, 57 57 z: 10, 58 58 - restitution: 2, 59 58 color: ex.Color.Red, 60 60 - visible: false, 61 61 - collisionType: ex.CollisionType.Fixed 59 59 + visible: false 62 60 }); 63 61 64 62 const actor2 = new ex.Actor({ 65 65 - x: 4, 66 66 - y: 5 63 63 + pos: new ex.Vector(4, 5) 67 64 }); 68 65 69 69 - expect(actor.x).toBe(2); 70 70 - expect(actor.y).toBe(3); 71 71 - expect(actor.getWidth()).toBe(100); 72 72 - expect(actor.getHeight()).toBe(200); 66 66 + expect(actor.pos.x).toBe(2); 67 67 + expect(actor.pos.y).toBe(3); 68 68 + expect(actor.width).toBe(100); 69 69 + expect(actor.height).toBe(200); 73 70 expect(actor.vel.x).toBe(30); 74 71 expect(actor.vel.y).toBe(40); 75 72 expect(actor.acc.x).toBe(50); ··· 79 76 expect(actor.z).toBe(10); 80 77 expect(actor.color.toString()).toBe(ex.Color.Red.toString()); 81 78 expect(actor.visible).toBe(false); 82 82 - expect(actor.restitution).toBe(2); 83 83 - expect(actor.collisionType).toBe(ex.CollisionType.Fixed); 84 84 - expect(actor2.x).toBe(4); 85 85 - expect(actor2.y).toBe(5); 79 79 + expect(actor2.pos.x).toBe(4); 80 80 + expect(actor2.pos.y).toBe(5); 86 81 }); 87 82 88 83 it('should have default properties set', () => { ··· 122 117 const actor2 = new ex.Actor(); 123 118 actor2.id = 40; 124 119 125 125 - const hash = ex.Pair.calculatePairHash(actor.body, actor2.body); 126 126 - const hash2 = ex.Pair.calculatePairHash(actor2.body, actor.body); 120 120 + const hash = ex.Pair.calculatePairHash(actor.body.collider, actor2.body.collider); 121 121 + const hash2 = ex.Pair.calculatePairHash(actor2.body.collider, actor.body.collider); 127 122 expect(hash).toBe('#20+40'); 128 123 expect(hash2).toBe('#20+40'); 129 124 }); ··· 160 155 }); 161 156 162 157 it('can have its height and width scaled', () => { 163 163 - expect(actor.getWidth()).toBe(0); 164 164 - expect(actor.getHeight()).toBe(0); 158 158 + expect(actor.width).toBe(0); 159 159 + expect(actor.height).toBe(0); 165 160 166 166 - actor.setWidth(20); 167 167 - actor.setHeight(20); 161 161 + actor.width = 20; 162 162 + actor.height = 20; 168 163 169 169 - expect(actor.getWidth()).toBe(20); 170 170 - expect(actor.getHeight()).toBe(20); 164 164 + expect(actor.width).toBe(20); 165 165 + expect(actor.height).toBe(20); 171 166 172 167 actor.scale.x = 2; 173 168 actor.scale.y = 3; 174 169 175 175 - expect(actor.getWidth()).toBe(40); 176 176 - expect(actor.getHeight()).toBe(60); 170 170 + expect(actor.width).toBe(40); 171 171 + expect(actor.height).toBe(60); 177 172 178 173 actor.scale.x = 0.5; 179 174 actor.scale.y = 0.1; 180 175 181 181 - expect(actor.getWidth()).toBe(10); 182 182 - expect(actor.getHeight()).toBe(2); 176 176 + expect(actor.width).toBe(10); 177 177 + expect(actor.height).toBe(2); 183 178 }); 184 179 185 180 it('can have its height and width scaled by parent', () => { ··· 189 184 190 185 actor.add(child); 191 186 192 192 - expect(child.getWidth()).toBe(100); 193 193 - expect(child.getHeight()).toBe(100); 187 187 + expect(child.width).toBe(100); 188 188 + expect(child.height).toBe(100); 194 189 195 190 actor.scale.setTo(0.5, 0.5); 196 191 197 197 - expect(child.getWidth()).toBe(25); 198 198 - expect(child.getHeight()).toBe(25); 192 192 + expect(child.width).toBe(25); 193 193 + expect(child.height).toBe(25); 199 194 }); 200 195 201 196 it('can have a center point', () => { 202 202 - actor.setHeight(100); 203 203 - actor.setWidth(50); 197 197 + actor.height = 100; 198 198 + actor.width = 50; 204 199 205 205 - let center = actor.getCenter(); 200 200 + let center = actor.center; 206 201 expect(center.x).toBe(0); 207 202 expect(center.y).toBe(0); 208 203 209 204 actor.pos.x = 100; 210 205 actor.pos.y = 100; 211 206 212 212 - center = actor.getCenter(); 207 207 + center = actor.center; 213 208 expect(center.x).toBe(100); 214 209 expect(center.y).toBe(100); 215 210 ··· 218 213 actor.pos.x = 0; 219 214 actor.pos.y = 0; 220 215 221 221 - center = actor.getCenter(); 216 216 + center = actor.center; 222 217 expect(center.x).toBe(25); 223 218 expect(center.y).toBe(50); 224 219 225 220 actor.pos.x = 100; 226 221 actor.pos.y = 100; 227 222 228 228 - center = actor.getCenter(); 223 223 + center = actor.center; 229 224 expect(center.x).toBe(125); 230 225 expect(center.y).toBe(150); 231 226 }); ··· 234 229 actor.pos.x = 0; 235 230 actor.pos.y = 0; 236 231 actor.anchor = new ex.Vector(0.5, 0.5); 237 237 - actor.setWidth(100); 238 238 - actor.setHeight(100); 232 232 + actor.width = 100; 233 233 + actor.height = 100; 239 234 240 240 - expect(actor.getLeft()).toBe(-50); 241 241 - expect(actor.getRight()).toBe(50); 242 242 - expect(actor.getTop()).toBe(-50); 243 243 - expect(actor.getBottom()).toBe(50); 235 235 + expect(actor.body.collider.bounds.left).toBe(-50); 236 236 + expect(actor.body.collider.bounds.right).toBe(50); 237 237 + expect(actor.body.collider.bounds.top).toBe(-50); 238 238 + expect(actor.body.collider.bounds.bottom).toBe(50); 244 239 }); 245 240 246 241 it('should have correct bounds when scaled', () => { 247 242 actor.pos.x = 0; 248 243 actor.pos.y = 0; 249 249 - actor.setWidth(100); 250 250 - actor.setHeight(100); 244 244 + actor.width = 100; 245 245 + actor.height = 100; 251 246 actor.scale.setTo(2, 2); 252 247 actor.anchor = new ex.Vector(0.5, 0.5); 253 248 254 254 - expect(actor.getLeft()).toBe(-100); 255 255 - expect(actor.getRight()).toBe(100); 256 256 - expect(actor.getTop()).toBe(-100); 257 257 - expect(actor.getBottom()).toBe(100); 249 249 + actor.body.collider.shape.recalc(); 250 250 + 251 251 + expect(actor.body.collider.bounds.left).toBe(-100); 252 252 + expect(actor.body.collider.bounds.right).toBe(100); 253 253 + expect(actor.body.collider.bounds.top).toBe(-100); 254 254 + expect(actor.body.collider.bounds.bottom).toBe(100); 258 255 }); 259 256 260 260 - it('should have correct bounds when parent is scaled', () => { 257 257 + // @obsolete? colliders don't know anything about child actors 258 258 + xit('should have correct bounds when parent is scaled', () => { 261 259 actor.pos.x = 0; 262 260 actor.pos.y = 0; 263 263 - actor.setWidth(100); 264 264 - actor.setHeight(100); 261 261 + actor.width = 100; 262 262 + actor.height = 100; 265 263 actor.scale.setTo(2, 2); 266 264 actor.anchor = new ex.Vector(0.5, 0.5); 267 265 268 266 const child = new ex.Actor(0, 0, 50, 50); 269 267 actor.add(child); 270 268 271 271 - expect(child.getLeft()).toBe(-50); 272 272 - expect(child.getRight()).toBe(50); 273 273 - expect(child.getTop()).toBe(-50); 274 274 - expect(child.getBottom()).toBe(50); 269 269 + expect(child.body.collider.bounds.left).toBe(-50); 270 270 + expect(child.body.collider.bounds.right).toBe(50); 271 271 + expect(child.body.collider.bounds.top).toBe(-50); 272 272 + expect(child.body.collider.bounds.bottom).toBe(50); 275 273 }); 276 274 277 277 - it('should have the correct bounds when scaled and rotated', () => { 275 275 + xit('should have the correct bounds when scaled and rotated', () => { 278 276 const actor = new ex.Actor(50, 50, 10, 10); 279 277 // actor is now 20 high 280 278 actor.scale.setTo(1, 2); 281 279 // rotating the actor 90 degrees should make the actor 20 wide 282 280 actor.rotation = Math.PI / 2; 283 283 - const bounds = actor.getBounds(); 284 284 - expect(bounds.getWidth()).toBeCloseTo(20, 0.001); 285 285 - expect(bounds.getHeight()).toBeCloseTo(10, 0.001); 281 281 + const bounds = actor.body.collider.bounds; 282 282 + expect(bounds.width).toBeCloseTo(20, 0.001); 283 283 + expect(bounds.height).toBeCloseTo(10, 0.001); 286 284 287 285 expect(bounds.left).toBeCloseTo(40, 0.001); 288 286 expect(bounds.right).toBeCloseTo(60, 0.001); ··· 290 288 expect(bounds.bottom).toBeCloseTo(55, 0.001); 291 289 }); 292 290 293 293 - it('should have the correct relative bounds when scaled and rotated', () => { 291 291 + xit('should have the correct relative bounds when scaled and rotated', () => { 294 292 const actor = new ex.Actor(50, 50, 10, 10); 295 293 // actor is now 20 high 296 294 actor.scale.setTo(1, 2); 297 295 // rotating the actor 90 degrees should make the actor 20 wide 298 296 actor.rotation = Math.PI / 2; 299 299 - const bounds = actor.getRelativeBounds(); 300 300 - expect(bounds.getWidth()).toBeCloseTo(20, 0.001); 301 301 - expect(bounds.getHeight()).toBeCloseTo(10, 0.001); 297 297 + const bounds = actor.body.collider.localBounds; 298 298 + expect(bounds.width).toBeCloseTo(20, 0.001); 299 299 + expect(bounds.height).toBeCloseTo(10, 0.001); 302 300 303 301 expect(bounds.left).toBeCloseTo(-10, 0.001); 304 302 expect(bounds.right).toBeCloseTo(10, 0.001); ··· 306 304 expect(bounds.bottom).toBeCloseTo(5, 0.001); 307 305 }); 308 306 309 309 - it('has a left, right, top, and bottom when the anchor is (0, 0)', () => { 307 307 + xit('has a left, right, top, and bottom when the anchor is (0, 0)', () => { 310 308 actor.pos.x = 100; 311 309 actor.pos.y = 100; 312 310 actor.anchor = new ex.Vector(0.0, 0.0); 313 313 - actor.setWidth(100); 314 314 - actor.setHeight(100); 311 311 + actor.width = 100; 312 312 + actor.height = 100; 315 313 316 316 - expect(actor.getLeft()).toBe(100); 317 317 - expect(actor.getRight()).toBe(200); 318 318 - expect(actor.getTop()).toBe(100); 319 319 - expect(actor.getBottom()).toBe(200); 314 314 + expect(actor.body.collider.bounds.left).toBe(100); 315 315 + expect(actor.body.collider.bounds.right).toBe(200); 316 316 + expect(actor.body.collider.bounds.top).toBe(100); 317 317 + expect(actor.body.collider.bounds.bottom).toBe(200); 320 318 }); 321 319 322 322 - it('should have the correct world geometry if rotated and scaled', () => { 320 320 + xit('should have the correct world geometry if rotated and scaled', () => { 323 321 const actor = new ex.Actor({ pos: new ex.Vector(50, 50), width: 10, height: 10 }); 324 322 actor.scale.setTo(2, 2); 325 323 actor.rotation = Math.PI / 2; ··· 332 330 expect(geom[3].equals(new ex.Vector(40, 60))).toBe(true); 333 331 }); 334 332 335 335 - it('should have the correct relative geometry if rotated and scaled', () => { 333 333 + xit('should have the correct relative geometry if rotated and scaled', () => { 336 334 const actor = new ex.Actor({ pos: new ex.Vector(50, 50), width: 10, height: 10 }); 337 335 actor.scale.setTo(2, 2); 338 336 actor.rotation = Math.PI / 2; ··· 345 343 expect(geom[3].equals(new ex.Vector(-10, 10))).toBe(true); 346 344 }); 347 345 348 348 - it('can contain points', () => { 346 346 + xit('can contain points', () => { 349 347 expect(actor.pos.x).toBe(0); 350 348 expect(actor.pos.y).toBe(0); 351 351 - actor.setWidth(20); 352 352 - actor.setHeight(20); 349 349 + actor.width = 20; 350 350 + actor.height = 20; 353 351 354 352 expect(actor.anchor.x).toBe(0.5); 355 353 expect(actor.anchor.y).toBe(0.5); ··· 370 368 const other = new ex.Actor(10, 10, 10, 10); 371 369 372 370 // Actors are adjacent and not overlapping should not collide 373 373 - expect(actor.collidesWithSide(other)).toBeFalsy(); 374 374 - expect(other.collidesWithSide(actor)).toBeFalsy(); 371 371 + expect(actor.body.collider.bounds.intersectWithSide(other.body.collider.bounds)).toBe(ex.Side.None); 372 372 + expect(other.body.collider.bounds.intersectWithSide(actor.body.collider.bounds)).toBe(ex.Side.None); 375 373 376 374 // move other actor into collision range from the right side 377 375 other.pos.x = 9; 378 376 other.pos.y = 0; 379 379 - expect(actor.collidesWithSide(other)).toBe(ex.Side.Right); 380 380 - expect(other.collidesWithSide(actor)).toBe(ex.Side.Left); 377 377 + expect(actor.body.collider.bounds.intersectWithSide(other.body.collider.bounds)).toBe(ex.Side.Right); 378 378 + expect(other.body.collider.bounds.intersectWithSide(actor.body.collider.bounds)).toBe(ex.Side.Left); 381 379 382 380 // move other actor into collision range from the left side 383 381 other.pos.x = -9; 384 382 other.pos.y = 0; 385 385 - expect(actor.collidesWithSide(other)).toBe(ex.Side.Left); 386 386 - expect(other.collidesWithSide(actor)).toBe(ex.Side.Right); 383 383 + expect(actor.body.collider.bounds.intersectWithSide(other.body.collider.bounds)).toBe(ex.Side.Left); 384 384 + expect(other.body.collider.bounds.intersectWithSide(actor.body.collider.bounds)).toBe(ex.Side.Right); 387 385 388 386 // move other actor into collision range from the top 389 387 other.pos.x = 0; 390 388 other.pos.y = -9; 391 391 - expect(actor.collidesWithSide(other)).toBe(ex.Side.Top); 392 392 - expect(other.collidesWithSide(actor)).toBe(ex.Side.Bottom); 389 389 + expect(actor.body.collider.bounds.intersectWithSide(other.body.collider.bounds)).toBe(ex.Side.Top); 390 390 + expect(other.body.collider.bounds.intersectWithSide(actor.body.collider.bounds)).toBe(ex.Side.Bottom); 393 391 394 392 // move other actor into collision range from the bottom 395 393 other.pos.x = 0; 396 394 other.pos.y = 9; 397 397 - expect(actor.collidesWithSide(other)).toBe(ex.Side.Bottom); 398 398 - expect(other.collidesWithSide(actor)).toBe(ex.Side.Top); 395 395 + expect(actor.body.collider.bounds.intersectWithSide(other.body.collider.bounds)).toBe(ex.Side.Bottom); 396 396 + expect(other.body.collider.bounds.intersectWithSide(actor.body.collider.bounds)).toBe(ex.Side.Top); 399 397 }); 400 398 401 399 it('participates with another in a collision', () => { 402 400 const actor = new ex.Actor(0, 0, 10, 10); 403 403 - actor.collisionType = ex.CollisionType.Active; 401 401 + actor.body.collider.type = ex.CollisionType.Active; 404 402 const other = new ex.Actor(8, 0, 10, 10); 405 405 - other.collisionType = ex.CollisionType.Active; 403 403 + other.body.collider.type = ex.CollisionType.Active; 406 404 let actorCalled = 'false'; 407 405 let otherCalled = 'false'; 408 406 ··· 661 659 const scene = new ex.Scene(engine); 662 660 663 661 const active = new ex.Actor(0, -50, 100, 100); 664 664 - active.collisionType = ex.CollisionType.Active; 662 662 + active.body.collider.type = ex.CollisionType.Active; 665 663 active.vel.y = 10; 666 664 active.acc.y = 1000; 667 665 668 666 const fixed = new ex.Actor(-100, 50, 1000, 100); 669 669 - fixed.collisionType = ex.CollisionType.Fixed; 667 667 + fixed.body.collider.type = ex.CollisionType.Fixed; 670 668 671 669 scene.add(active); 672 670 scene.add(fixed); ··· 692 690 it('with an active collision type can jump on a fixed type', () => { 693 691 const scene = new ex.Scene(engine); 694 692 const active = new ex.Actor(0, -50, 100, 100); 695 695 - active.collisionType = ex.CollisionType.Active; 693 693 + active.body.collider.type = ex.CollisionType.Active; 696 694 active.vel.y = -100; 697 695 ex.Physics.acc.setTo(0, 0); 698 696 699 697 const fixed = new ex.Actor(-100, 50, 1000, 100); 700 700 - fixed.collisionType = ex.CollisionType.Fixed; 698 698 + fixed.body.collider.type = ex.CollisionType.Fixed; 701 699 702 700 scene.add(active); 703 701 scene.add(fixed); ··· 1291 1289 const texture = new ex.Texture('base/src/spec/images/SpriteSpec/icon.png', true); 1292 1290 texture.load().then(() => { 1293 1291 const actor = new ex.Actor({ 1294 1294 - x: engine.halfCanvasWidth, 1295 1295 - y: engine.halfCanvasHeight, 1292 1292 + pos: new ex.Vector(engine.halfCanvasWidth, engine.halfCanvasHeight), 1296 1293 width: 10, 1297 1294 height: 10, 1298 1295 rotation: Math.PI / 4 ··· 1354 1351 1355 1352 it('can be offscreen', () => { 1356 1353 const actor = new ex.Actor({ 1357 1357 - x: 0, 1358 1358 - y: 0, 1354 1354 + pos: ex.Vector.Zero, 1359 1355 width: 10, 1360 1356 height: 10 1361 1357 }); ··· 1365 1361 1366 1362 expect(actor.isOffScreen).toBe(false, 'Actor should be onscreen'); 1367 1363 1368 1368 - actor.x = 106; 1364 1364 + actor.pos.x = 106; 1369 1365 scene.update(engine, 100); 1370 1366 1371 1367 expect(actor.isOffScreen).toBe(true, 'Actor should be offscreen');

+32 -32

src/spec/BoundingBoxSpec.ts

Reviewed

··· 8 8 }); 9 9 10 10 it('has a width', () => { 11 11 - expect(bb.getWidth()).toBe(10); 11 11 + expect(bb.width).toBe(10); 12 12 bb.right = 20; 13 13 - expect(bb.getWidth()).toBe(20); 13 13 + expect(bb.width).toBe(20); 14 14 bb.left = -20; 15 15 - expect(bb.getWidth()).toBe(40); 15 15 + expect(bb.width).toBe(40); 16 16 bb.top = -20; 17 17 - expect(bb.getWidth()).toBe(40); 17 17 + expect(bb.width).toBe(40); 18 18 }); 19 19 20 20 it('has a height', () => { 21 21 - expect(bb.getHeight()).toBe(10); 21 21 + expect(bb.height).toBe(10); 22 22 bb.right = 20; 23 23 - expect(bb.getHeight()).toBe(10); 23 23 + expect(bb.height).toBe(10); 24 24 bb.bottom = 20; 25 25 - expect(bb.getHeight()).toBe(20); 25 25 + expect(bb.height).toBe(20); 26 26 bb.top = -20; 27 27 - expect(bb.getHeight()).toBe(40); 27 27 + expect(bb.height).toBe(40); 28 28 }); 29 29 30 30 it('can contain points', () => { ··· 53 53 const b3 = new ex.BoundingBox(12, 0, 28, 10); 54 54 55 55 // bb should resolve by being displaced -8 to the left against b2 56 56 - expect(bb.collides(b2).x).toBe(-8); 56 56 + expect(bb.intersect(b2).x).toBe(-8); 57 57 58 58 // b2 should resolve by being displaced -8 to the left against b3 59 59 - expect(b2.collides(b3).x).toBe(-8); 59 59 + expect(b2.intersect(b3).x).toBe(-8); 60 60 61 61 // bb should not collide with b3, they are only touching 62 62 - expect(bb.collides(b3)).toBeFalsy(); 62 62 + expect(bb.intersect(b3)).toBeFalsy(); 63 63 64 64 b2.top = 5; 65 65 b2.left = 6; ··· 67 67 b2.bottom = 15; 68 68 69 69 // bb should be displaced up and out by -5 against b2 70 70 - expect(bb.collides(b2).x).toBe(-4); 70 70 + expect(bb.intersect(b2).x).toBe(-4); 71 71 }); 72 72 73 73 it('can collide with other bounding boxes with width/height (0,0)', () => { 74 74 const bb = new ex.BoundingBox(18, 15, 18, 15); // point bounding box 75 75 const bb2 = new ex.BoundingBox(0, 0, 20, 20); // square bounding box; 76 76 77 77 - expect(bb2.collides(bb)).not.toBe(null, 'Point bounding boxes should still collide'); 78 78 - expect(bb2.collides(bb).x).toBe(-2); 79 79 - expect(bb2.collides(bb).y).toBe(0); 77 77 + expect(bb2.intersect(bb)).not.toBe(null, 'Point bounding boxes should still collide'); 78 78 + expect(bb2.intersect(bb).x).toBe(-2); 79 79 + expect(bb2.intersect(bb).y).toBe(0); 80 80 }); 81 81 82 82 describe('when in full containment', () => { 83 83 it('closest right', () => { 84 84 const bb = new ex.BoundingBox(0, 0, 50, 50); 85 85 const bb1 = new ex.BoundingBox(40, 8, 49, 12); 86 86 - expect(bb.collides(bb1)).not.toBe(null); 87 87 - expect(bb.collides(bb1).x).toBe(-10, 'X should be -10'); 88 88 - expect(bb.collides(bb1).y).toBe(0, 'Y should be 0'); 86 86 + expect(bb.intersect(bb1)).not.toBe(null); 87 87 + expect(bb.intersect(bb1).x).toBe(-10, 'X should be -10'); 88 88 + expect(bb.intersect(bb1).y).toBe(0, 'Y should be 0'); 89 89 }); 90 90 91 91 it('closet left', () => { 92 92 const bb = new ex.BoundingBox(0, 0, 50, 50); 93 93 const bb1 = new ex.BoundingBox(1, 15, 10, 20); 94 94 - expect(bb.collides(bb1)).not.toBe(null); 95 95 - expect(bb.collides(bb1).x).toBe(10, 'X should be 10'); 96 96 - expect(bb.collides(bb1).y).toBe(0, 'Y should be 0'); 94 94 + expect(bb.intersect(bb1)).not.toBe(null); 95 95 + expect(bb.intersect(bb1).x).toBe(10, 'X should be 10'); 96 96 + expect(bb.intersect(bb1).y).toBe(0, 'Y should be 0'); 97 97 }); 98 98 99 99 it('closest top', () => { 100 100 const bb = new ex.BoundingBox(0, 0, 50, 50); 101 101 const bb1 = new ex.BoundingBox(10, 1, 12, 10); 102 102 - expect(bb.collides(bb1)).not.toBe(null); 103 103 - expect(bb.collides(bb1).x).toBe(0, 'X should be 0'); 104 104 - expect(bb.collides(bb1).y).toBe(10, 'Y should be 0'); 102 102 + expect(bb.intersect(bb1)).not.toBe(null); 103 103 + expect(bb.intersect(bb1).x).toBe(0, 'X should be 0'); 104 104 + expect(bb.intersect(bb1).y).toBe(10, 'Y should be 0'); 105 105 }); 106 106 107 107 it('closest bottom', () => { 108 108 const bb = new ex.BoundingBox(0, 0, 50, 50); 109 109 const bb1 = new ex.BoundingBox(10, 40, 12, 49); 110 110 - expect(bb.collides(bb1)).not.toBe(null); 111 111 - expect(bb.collides(bb1).x).toBe(0, 'X should be 0'); 112 112 - expect(bb.collides(bb1).y).toBe(-10, 'Y should be -10'); 110 110 + expect(bb.intersect(bb1)).not.toBe(null); 111 111 + expect(bb.intersect(bb1).x).toBe(0, 'X should be 0'); 112 112 + expect(bb.intersect(bb1).y).toBe(-10, 'Y should be -10'); 113 113 }); 114 114 }); 115 115 ··· 117 117 const bb1 = new ex.BoundingBox(0, 0, 10, 10); 118 118 const bb2 = new ex.BoundingBox(0, 0, 10, 10); 119 119 120 120 - expect(bb2.collides(bb1)).not.toBe(null); 121 121 - expect(bb2.collides(bb1).x).toBe(0); 122 122 - expect(bb2.collides(bb1).y).toBe(-10); 120 120 + expect(bb2.intersect(bb1)).not.toBe(null); 121 121 + expect(bb2.intersect(bb1).x).toBe(0); 122 122 + expect(bb2.intersect(bb1).y).toBe(-10); 123 123 }); 124 124 125 125 it('can combine with other bounding boxes', () => { ··· 127 127 const b3 = new ex.BoundingBox(12, 0, 28, 10); 128 128 const newBB = b2.combine(b3); 129 129 130 130 - expect(newBB.getWidth()).toBe(26); 131 131 - expect(newBB.getHeight()).toBe(10); 130 130 + expect(newBB.width).toBe(26); 131 131 + expect(newBB.height).toBe(10); 132 132 133 133 expect(newBB.left).toBe(2); 134 134 expect(newBB.right).toBe(28);

+2 -2

src/spec/CameraSpec.ts

Reviewed

··· 25 25 engine.backgroundColor = ex.Color.Blue; 26 26 27 27 actor.pos.x = 250; 28 28 - actor.setWidth(10); 28 28 + actor.width = 10; 29 29 actor.pos.y = 250; 30 30 - actor.setHeight(10); 30 30 + actor.height = 10; 31 31 actor.color = ex.Color.Red; 32 32 scene = new ex.Scene(engine); 33 33 scene.add(actor);

+259 -44

src/spec/CollisionAreaSpec.ts src/spec/CollisionShapeSpec.ts

Reviewed

··· 1 1 import * as ex from '../../build/dist/excalibur'; 2 2 + import { ExcaliburMatchers, ensureImagesLoaded } from 'excalibur-jasmine'; 3 3 + import { TestUtils } from './util/TestUtils'; 2 4 3 3 - describe('Collision areas', () => { 4 4 - describe('A Circle shape', () => { 5 5 + describe('Collision Shape', () => { 6 6 + beforeAll(() => { 7 7 + jasmine.addMatchers(ExcaliburMatchers); 8 8 + }); 9 9 + 10 10 + describe('a Circle', () => { 11 11 + let engine: ex.Engine; 12 12 + let scene: ex.Scene; 13 13 + 5 14 let circle: ex.CircleArea; 6 15 let actor: ex.Actor; 7 16 8 17 beforeEach(() => { 18 18 + engine = TestUtils.engine(); 19 19 + scene = new ex.Scene(engine); 20 20 + engine.currentScene = scene; 21 21 + 9 22 actor = new ex.Actor(0, 0, 20, 20); 10 23 circle = new ex.CircleArea({ 11 24 pos: ex.Vector.Zero.clone(), ··· 14 27 }); 15 28 }); 16 29 30 30 + afterEach(() => { 31 31 + engine.stop(); 32 32 + engine = null; 33 33 + }); 34 34 + 17 35 it('exists', () => { 18 36 expect(ex.CircleArea).toBeDefined(); 19 37 }); 20 38 21 39 it('can be constructed with empty args', () => { 22 22 - const circle = new ex.CircleArea({}); 40 40 + const circle = new ex.CircleArea({ 41 41 + radius: 1 42 42 + }); 23 43 expect(circle).not.toBeNull(); 24 44 }); 25 45 46 46 + it('can be cloned', () => { 47 47 + const actor1 = new ex.Actor(0, 0, 20, 20); 48 48 + const circle = new ex.CircleArea({ 49 49 + collider: actor1.body.collider, 50 50 + radius: 10, 51 51 + pos: new ex.Vector(20, 25) 52 52 + }); 53 53 + 54 54 + const sut = circle.clone(); 55 55 + 56 56 + expect(sut).not.toBe(circle); 57 57 + expect(sut.pos).toBeVector(circle.pos); 58 58 + expect(sut.pos).not.toBe(circle.pos); 59 59 + expect(sut.collider).toBe(null); 60 60 + }); 61 61 + 26 62 it('can be constructed with points', () => { 27 63 const actor = new ex.Actor(0, 0, 10, 10); 28 64 const circle = new ex.CircleArea({ ··· 35 71 36 72 it('has a center', () => { 37 73 actor.pos.setTo(170, 300); 38 38 - const center = circle.getCenter(); 74 74 + const center = circle.center; 39 75 expect(center.x).toBe(170); 40 76 expect(center.y).toBe(300); 41 77 }); ··· 43 79 it('has bounds', () => { 44 80 actor.pos.setTo(400, 400); 45 81 46 46 - const bounds = circle.getBounds(); 82 82 + const bounds = circle.bounds; 47 83 expect(bounds.left).toBe(390); 48 84 expect(bounds.right).toBe(410); 49 85 expect(bounds.top).toBe(390); ··· 82 118 83 119 it('doesnt have axes', () => { 84 120 // technically circles have infinite axes 85 85 - expect(circle.getAxes()).toBe(null); 121 121 + expect(circle.axes).toBe(null); 86 122 }); 87 123 88 124 it('has a moment of inertia', () => { 89 125 // following this formula 90 126 //https://en.wikipedia.org/wiki/List_of_moments_of_inertia 91 127 // I = m*r^2/2 92 92 - expect(circle.getMomentOfInertia()).toBe((circle.body.mass * circle.radius * circle.radius) / 2); 128 128 + expect(circle.inertia).toBe((circle.body.collider.mass * circle.radius * circle.radius) / 2); 129 129 + }); 130 130 + 131 131 + it('should collide without a collider or body', () => { 132 132 + const circle1 = new ex.CircleArea({ 133 133 + pos: new ex.Vector(0, 0), 134 134 + radius: 5 135 135 + }); 136 136 + 137 137 + const circle2 = new ex.CircleArea({ 138 138 + pos: new ex.Vector(9, 0), 139 139 + radius: 5 140 140 + }); 141 141 + 142 142 + const cc = circle1.collide(circle2); 143 143 + expect(cc.mtv).toBeVector(new ex.Vector(1, 0)); 93 144 }); 94 145 95 146 it('should collide with other circles when touching', () => { ··· 99 150 body: actor2.body 100 151 }); 101 152 102 102 - const directionOfBodyB = circle2.getCenter().sub(circle.getCenter()); 153 153 + const directionOfBodyB = circle2.center.sub(circle.center); 103 154 const contact = circle.collide(circle2); 104 155 105 156 // there should be a collision contact formed ··· 130 181 131 182 it('should collide with other polygons when touching', () => { 132 183 const actor2 = new ex.Actor(14.99, 0, 10, 10); // meh close enough 133 133 - const poly = new ex.PolygonArea({ 184 184 + const poly = new ex.ConvexPolygon({ 134 185 pos: ex.Vector.Zero.clone(), 135 135 - points: actor2.getRelativeBounds().getPoints(), 186 186 + points: actor2.body.collider.localBounds.getPoints(), 136 187 body: actor2.body 137 188 }); 138 189 139 139 - const directionOfBodyB = poly.getCenter().sub(circle.getCenter()); 190 190 + const directionOfBodyB = poly.center.sub(circle.center); 140 191 const contact = circle.collide(poly); 141 192 142 193 // there should be a collision contact formed ··· 154 205 155 206 it('should not collide with other polygons when not touching', () => { 156 207 const actor2 = new ex.Actor(16, 0, 10, 10); 157 157 - const poly = new ex.PolygonArea({ 208 208 + const poly = new ex.ConvexPolygon({ 158 209 pos: ex.Vector.Zero.clone(), 159 159 - points: actor2.getRelativeBounds().getPoints(), 210 210 + points: actor2.body.collider.localBounds.getPoints(), 160 211 body: actor2.body 161 212 }); 162 213 ··· 174 225 const edge = new ex.EdgeArea({ 175 226 begin: new ex.Vector(0, 0), 176 227 end: new ex.Vector(10, 0), 177 177 - body: actor2.body 228 228 + collider: actor2.body.collider 178 229 }); 179 230 180 180 - const directionOfBodyB = edge.getCenter().sub(circle.getCenter()); 231 231 + const directionOfBodyB = edge.center.sub(circle.center); 181 232 const contact = circle.collide(edge); 182 233 183 234 // there should be a collision contact formed ··· 201 252 const edge = new ex.EdgeArea({ 202 253 begin: new ex.Vector(0, 0), 203 254 end: new ex.Vector(10, 0), 204 204 - body: actor2.body 255 255 + collider: actor2.body.collider 205 256 }); 206 257 207 207 - const directionOfBodyB = edge.getCenter().sub(circle.getCenter()); 258 258 + const directionOfBodyB = edge.center.sub(circle.center); 208 259 const contact = circle.collide(edge); 209 260 210 261 // there should be a collision contact formed ··· 228 279 const edge = new ex.EdgeArea({ 229 280 begin: new ex.Vector(0, 0), 230 281 end: new ex.Vector(10, 0), 231 231 - body: actor2.body 282 282 + collider: actor2.body.collider 232 283 }); 233 284 234 234 - const directionOfBodyB = edge.getCenter().sub(circle.getCenter()); 285 285 + const directionOfBodyB = edge.center.sub(circle.center); 235 286 const contact = circle.collide(edge); 236 287 237 288 // there should be a collision contact formed ··· 246 297 expect(contact.point.x).toBe(0); 247 298 expect(contact.point.y).toBe(0); 248 299 }); 300 300 + 301 301 + it('can be drawn', (done) => { 302 302 + const circle = new ex.Circle({ 303 303 + pos: new ex.Vector(100, 100), 304 304 + radius: 30 305 305 + }); 306 306 + 307 307 + circle.draw(engine.ctx, ex.Color.Blue, new ex.Vector(50, 0)); 308 308 + 309 309 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/circle.png').then(([canvas, image]) => { 310 310 + expect(canvas).toEqualImage(image); 311 311 + done(); 312 312 + }); 313 313 + }); 314 314 + 315 315 + it('can be drawn with actor', (done) => { 316 316 + const circleActor = new ex.Actor({ 317 317 + pos: new ex.Vector(150, 100), 318 318 + color: ex.Color.Blue, 319 319 + body: new ex.Body({ 320 320 + collider: new ex.Collider({ 321 321 + shape: ex.Shape.Circle(30) 322 322 + }) 323 323 + }) 324 324 + }); 325 325 + 326 326 + scene.add(circleActor); 327 327 + scene.draw(engine.ctx, 100); 328 328 + 329 329 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/circle.png').then(([canvas, image]) => { 330 330 + expect(canvas).toEqualImage(image); 331 331 + done(); 332 332 + }); 333 333 + }); 249 334 }); 250 335 251 251 - describe('A Polygon shape', () => { 336 336 + describe('a ConvexPolygon', () => { 337 337 + let engine: ex.Engine; 338 338 + let scene: ex.Scene; 339 339 + beforeEach(() => { 340 340 + engine = TestUtils.engine(); 341 341 + scene = new ex.Scene(engine); 342 342 + engine.currentScene = scene; 343 343 + }); 344 344 + 345 345 + afterEach(() => { 346 346 + engine.stop(); 347 347 + engine = null; 348 348 + }); 349 349 + 252 350 it('exists', () => { 253 253 - expect(ex.PolygonArea).toBeDefined(); 351 351 + expect(ex.ConvexPolygon).toBeDefined(); 254 352 }); 255 353 256 354 it('can be constructed with empty args', () => { 257 257 - const poly = new ex.PolygonArea({}); 355 355 + const poly = new ex.ConvexPolygon({ 356 356 + points: [ex.Vector.One] 357 357 + }); 258 358 expect(poly).not.toBe(null); 259 359 }); 260 360 361 361 + it('can be cloned', () => { 362 362 + const actor1 = new ex.Actor(0, 0, 20, 20); 363 363 + const poly = new ex.ConvexPolygon({ 364 364 + collider: actor1.body.collider, 365 365 + points: [ex.Vector.One, ex.Vector.Half], 366 366 + pos: new ex.Vector(20, 25) 367 367 + }); 368 368 + 369 369 + const sut = poly.clone(); 370 370 + 371 371 + expect(sut).not.toBe(poly); 372 372 + expect(sut.pos).toBeVector(poly.pos); 373 373 + expect(sut.pos).not.toBe(poly.pos); 374 374 + expect(sut.points.length).toBe(2); 375 375 + expect(sut.collider).toBe(null); 376 376 + }); 377 377 + 261 378 it('can be constructed with points', () => { 262 262 - const poly = new ex.PolygonArea({ 379 379 + const poly = new ex.ConvexPolygon({ 263 380 pos: ex.Vector.Zero.clone(), 264 381 points: [new ex.Vector(-10, -10), new ex.Vector(10, -10), new ex.Vector(10, 10), new ex.Vector(-10, 10)] 265 382 }); ··· 267 384 }); 268 385 269 386 it('can have be constructed with position', () => { 270 270 - const poly = new ex.PolygonArea({ 387 387 + const poly = new ex.ConvexPolygon({ 271 388 pos: new ex.Vector(10, 0), 272 389 points: [new ex.Vector(-10, -10), new ex.Vector(10, -10), new ex.Vector(10, 10), new ex.Vector(-10, 10)] 273 390 }); ··· 284 401 }); 285 402 286 403 it('can collide with other polygons', () => { 287 287 - const polyA = new ex.PolygonArea({ 404 404 + const polyA = new ex.ConvexPolygon({ 288 405 pos: ex.Vector.Zero.clone(), 289 406 // specified relative to the position 290 407 points: [new ex.Vector(-10, -10), new ex.Vector(10, -10), new ex.Vector(10, 10), new ex.Vector(-10, 10)] 291 408 }); 292 409 293 293 - const polyB = new ex.PolygonArea({ 410 410 + const polyB = new ex.ConvexPolygon({ 294 411 pos: new ex.Vector(10, 0), 295 412 points: [new ex.Vector(-10, -10), new ex.Vector(10, -10), new ex.Vector(10, 10), new ex.Vector(-10, 10)] 296 413 }); 297 414 298 298 - const directionOfBodyB = polyB.getCenter().sub(polyA.getCenter()); 415 415 + const directionOfBodyB = polyB.center.sub(polyA.center); 299 416 300 417 // should overlap by 10 pixels in x 301 418 const contact = polyA.collide(polyB); ··· 316 433 it('can collide with the middle of an edge', () => { 317 434 const actor = new ex.Actor(5, -6, 20, 20); 318 435 actor.rotation = Math.PI / 4; 319 319 - const polyA = new ex.PolygonArea({ 436 436 + const polyA = new ex.ConvexPolygon({ 320 437 pos: ex.Vector.Zero.clone(), 321 438 // specified relative to the position 322 439 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 331 448 body: actor2.body 332 449 }); 333 450 334 334 - const directionOfBodyB = edge.getCenter().sub(polyA.getCenter()); 451 451 + const directionOfBodyB = edge.center.sub(polyA.center); 335 452 336 453 const contact = polyA.collide(edge); 337 454 ··· 347 464 348 465 it('can collide with the end of an edge', () => { 349 466 const actor = new ex.Actor(0, -4, 20, 20); 350 350 - const polyA = new ex.PolygonArea({ 467 467 + const polyA = new ex.ConvexPolygon({ 351 468 pos: ex.Vector.Zero.clone(), 352 469 // specified relative to the position 353 470 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 363 480 }); 364 481 edge.recalc(); 365 482 366 366 - const directionOfBodyB = edge.getCenter().sub(polyA.getCenter()); 483 483 + const directionOfBodyB = edge.center.sub(polyA.center); 367 484 const contact = polyA.collide(edge); 368 485 369 486 expect(contact).not.toBe(null); ··· 375 492 376 493 it('can collide with the end of an edge regardless of order', () => { 377 494 const actor = new ex.Actor(0, -4, 20, 20); 378 378 - const polyA = new ex.PolygonArea({ 495 495 + const polyA = new ex.ConvexPolygon({ 379 496 pos: ex.Vector.Zero.clone(), 380 497 // specified relative to the position 381 498 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 391 508 }); 392 509 edge.recalc(); 393 510 394 394 - const directionOfBodyB = edge.getCenter().sub(polyA.getCenter()); 511 511 + const directionOfBodyB = edge.center.sub(polyA.center); 395 512 const contact = polyA.collide(edge); 396 513 397 514 expect(contact).not.toBe(null); ··· 404 521 it('should not collide with the middle of an edge when not touching', () => { 405 522 const actor = new ex.Actor(5, 0, 20, 20); 406 523 actor.rotation = Math.PI / 4; 407 407 - const polyA = new ex.PolygonArea({ 524 524 + const polyA = new ex.ConvexPolygon({ 408 525 pos: ex.Vector.Zero.clone(), 409 526 // specified relative to the position 410 527 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 419 536 body: actor2.body 420 537 }); 421 538 422 422 - const directionOfBodyB = edge.getCenter().sub(polyA.getCenter()); 539 539 + const directionOfBodyB = edge.center.sub(polyA.center); 423 540 424 541 const contact = polyA.collide(edge); 425 542 ··· 429 546 430 547 it('should detected contained points', () => { 431 548 const actor = new ex.Actor(0, 0, 20, 20); 432 432 - const polyA = new ex.PolygonArea({ 549 549 + const polyA = new ex.ConvexPolygon({ 433 550 pos: ex.Vector.Zero.clone(), 434 551 // specified relative to the position 435 552 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 447 564 }); 448 565 449 566 it('can calculate the closest face to a point', () => { 450 450 - const polyA = new ex.PolygonArea({ 567 567 + const polyA = new ex.ConvexPolygon({ 451 568 pos: ex.Vector.Zero.clone(), 452 569 // specified relative to the position 453 570 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)] ··· 489 606 490 607 it('can have ray cast to detect if the ray hits the polygon', () => { 491 608 const actor = new ex.Actor(0, 0, 20, 20); 492 492 - const polyA = new ex.PolygonArea({ 609 609 + const polyA = new ex.ConvexPolygon({ 493 610 pos: ex.Vector.Zero.clone(), 494 611 // specified relative to the position 495 612 points: [new ex.Vector(-5, -5), new ex.Vector(5, -5), new ex.Vector(5, 5), new ex.Vector(-5, 5)], ··· 509 626 expect(noHit).toBe(null); 510 627 expect(tooFar).toBe(null, 'The polygon should be too far away for a hit'); 511 628 }); 629 629 + 630 630 + it('can be drawn', (done) => { 631 631 + const polygon = new ex.ConvexPolygon({ 632 632 + pos: new ex.Vector(100, 100), 633 633 + points: [new ex.Vector(0, -100), new ex.Vector(-100, 50), new ex.Vector(100, 50)] 634 634 + }); 635 635 + 636 636 + polygon.draw(engine.ctx, ex.Color.Blue, new ex.Vector(50, 0)); 637 637 + 638 638 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/triangle.png').then(([canvas, image]) => { 639 639 + expect(canvas).toEqualImage(image); 640 640 + done(); 641 641 + }); 642 642 + }); 643 643 + 644 644 + it('can be drawn with actor', (done) => { 645 645 + const polygonActor = new ex.Actor({ 646 646 + pos: new ex.Vector(150, 100), 647 647 + color: ex.Color.Blue, 648 648 + body: new ex.Body({ 649 649 + collider: new ex.Collider({ 650 650 + shape: ex.Shape.Polygon([new ex.Vector(0, -100), new ex.Vector(-100, 50), new ex.Vector(100, 50)]) 651 651 + }) 652 652 + }) 653 653 + }); 654 654 + 655 655 + scene.add(polygonActor); 656 656 + scene.draw(engine.ctx, 100); 657 657 + 658 658 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/triangle.png').then(([canvas, image]) => { 659 659 + expect(canvas).toEqualImage(image); 660 660 + done(); 661 661 + }); 662 662 + }); 512 663 }); 513 664 514 514 - describe('An Edge shape', () => { 665 665 + describe('an Edge', () => { 515 666 let actor: ex.Actor = null; 516 667 let edge: ex.EdgeArea = null; 517 668 669 669 + let engine: ex.Engine; 670 670 + let scene: ex.Scene; 671 671 + 672 672 + afterEach(() => { 673 673 + engine.stop(); 674 674 + engine = null; 675 675 + }); 676 676 + 518 677 beforeEach(() => { 678 678 + engine = TestUtils.engine(); 679 679 + scene = new ex.Scene(engine); 680 680 + engine.currentScene = scene; 681 681 + 519 682 actor = new ex.Actor(5, 0, 10, 10); 520 683 edge = new ex.EdgeArea({ 521 684 begin: new ex.Vector(-5, 0), ··· 525 688 }); 526 689 527 690 it('has a center', () => { 528 528 - const center = edge.getCenter(); 691 691 + const center = edge.center; 529 692 530 693 expect(center.x).toBe(5); 531 694 expect(center.y).toBe(0); 532 695 }); 533 696 697 697 + it('can be cloned', () => { 698 698 + const actor1 = new ex.Actor(0, 0, 20, 20); 699 699 + const edge = new ex.Edge({ 700 700 + collider: actor1.body.collider, 701 701 + begin: ex.Vector.One, 702 702 + end: ex.Vector.Half 703 703 + }); 704 704 + 705 705 + const sut = edge.clone(); 706 706 + 707 707 + expect(sut).not.toBe(edge); 708 708 + expect(sut.pos).toBeVector(edge.pos); 709 709 + expect(sut.begin).toBeVector(edge.begin); 710 710 + expect(sut.end).toBeVector(edge.end); 711 711 + expect(sut.pos).not.toBe(edge.pos); 712 712 + expect(sut.collider).toBe(null); 713 713 + }); 714 714 + 534 715 it('has a length', () => { 535 716 const length = edge.getLength(); 536 717 expect(length).toBe(10); ··· 567 748 }); 568 749 569 750 it('has 4 axes', () => { 570 570 - const axes = edge.getAxes(); 751 751 + const axes = edge.axes; 571 752 expect(axes.length).toBe(4); 572 753 }); 573 754 574 755 it('has bounds', () => { 575 756 actor.pos.setTo(400, 400); 576 576 - const boundingBox = edge.getBounds(); 757 757 + const boundingBox = edge.bounds; 577 758 578 759 const transformedBegin = new ex.Vector(395, 400); 579 760 const transformedEnd = new ex.Vector(405, 400); ··· 585 766 it('has a moi', () => { 586 767 // following this formula https://en.wikipedia.org/wiki/List_of_moments_of_inertia 587 768 // rotates from the middle treating the ends as a point mass 588 588 - const moi = edge.getMomentOfInertia(); 769 769 + const moi = edge.inertia; 589 770 const length = edge.end.sub(edge.begin).distance() / 2; 590 590 - expect(moi).toBeCloseTo(edge.body.mass * length * length, 0.001); 771 771 + expect(moi).toBeCloseTo(edge.body.collider.mass * length * length, 0.001); 772 772 + }); 773 773 + 774 774 + it('can be drawn', (done) => { 775 775 + const edge = new ex.Edge({ 776 776 + begin: new ex.Vector(100, 100), 777 777 + end: new ex.Vector(400, 400) 778 778 + }); 779 779 + 780 780 + edge.draw(engine.ctx, ex.Color.Blue, new ex.Vector(50, 0)); 781 781 + 782 782 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/edge.png').then(([canvas, image]) => { 783 783 + expect(canvas).toEqualImage(image); 784 784 + done(); 785 785 + }); 786 786 + }); 787 787 + 788 788 + it('can be drawn with actor', (done) => { 789 789 + const edgeActor = new ex.Actor({ 790 790 + pos: new ex.Vector(150, 100), 791 791 + color: ex.Color.Blue, 792 792 + body: new ex.Body({ 793 793 + collider: new ex.Collider({ 794 794 + shape: ex.Shape.Edge(ex.Vector.Zero, new ex.Vector(300, 300)) 795 795 + }) 796 796 + }) 797 797 + }); 798 798 + 799 799 + scene.add(edgeActor); 800 800 + scene.draw(engine.ctx, 100); 801 801 + 802 802 + ensureImagesLoaded(engine.canvas, 'src/spec/images/CollisionShapeSpec/edge.png').then(([canvas, image]) => { 803 803 + expect(canvas).toEqualImage(image); 804 804 + done(); 805 805 + }); 591 806 }); 592 807 }); 593 808 });

+34 -32

src/spec/CollisionContactSpec.ts

Reviewed

··· 6 6 7 7 beforeEach(() => { 8 8 actorA = new ex.Actor(0, 0, 20, 20); 9 9 - actorA.collisionType = ex.CollisionType.Active; 10 10 - actorA.collisionArea = new ex.CircleArea({ 9 9 + const colliderA = actorA.body.collider; 10 10 + colliderA.type = ex.CollisionType.Active; 11 11 + colliderA.shape = new ex.Circle({ 11 12 radius: 10, 12 13 body: actorA.body 13 14 }); 14 15 15 16 actorB = new ex.Actor(20, 0, 20, 20); 16 16 - actorB.collisionType = ex.CollisionType.Active; 17 17 + const colliderB = actorB.body.collider; 18 18 + colliderB.type = ex.CollisionType.Active; 17 19 18 18 - actorB.collisionArea = new ex.CircleArea({ 20 20 + colliderB.shape = new ex.Circle({ 19 21 radius: 10, 20 22 body: actorB.body 21 23 }); ··· 27 29 28 30 it('can be created', () => { 29 31 const cc = new ex.CollisionContact( 30 30 - actorA.collisionArea, 31 31 - actorB.collisionArea, 32 32 + actorA.body.collider, 33 33 + actorB.body.collider, 32 34 ex.Vector.Zero.clone(), 33 35 new ex.Vector(10, 0), 34 36 ex.Vector.Right.clone() ··· 37 39 }); 38 40 39 41 it('can reslove in the Box system', () => { 40 40 - actorB.x = 19; 42 42 + actorB.pos.x = 19; 41 43 const cc = new ex.CollisionContact( 42 42 - actorA.collisionArea, 43 43 - actorB.collisionArea, 44 44 + actorA.body.collider, 45 45 + actorB.body.collider, 44 46 ex.Vector.Right.clone(), 45 47 new ex.Vector(10, 0), 46 48 ex.Vector.Right.clone() 47 49 ); 48 50 cc.resolve(ex.CollisionResolutionStrategy.Box); 49 51 50 50 - expect(actorA.x).toBe(-0.5); 51 51 - expect(actorA.y).toBe(0); 52 52 + expect(actorA.pos.x).toBe(-0.5); 53 53 + expect(actorA.pos.y).toBe(0); 52 54 53 53 - expect(actorB.x).toBe(19.5); 54 54 - expect(actorB.y).toBe(0); 55 55 + expect(actorB.pos.x).toBe(19.5); 56 56 + expect(actorB.pos.y).toBe(0); 55 57 }); 56 58 57 59 it('emits a collision event on both in the Box system', () => { ··· 66 68 emittedB = true; 67 69 }); 68 70 69 69 - actorB.x = 19; 71 71 + actorB.pos.x = 19; 70 72 const cc = new ex.CollisionContact( 71 71 - actorA.collisionArea, 72 72 - actorB.collisionArea, 73 73 + actorA.body.collider, 74 74 + actorB.body.collider, 73 75 ex.Vector.Right.clone(), 74 76 new ex.Vector(10, 0), 75 77 ex.Vector.Right.clone() ··· 81 83 }); 82 84 83 85 it('can reslove in the Dynamic system', () => { 84 84 - expect(actorA.x).toBe(0, 'Actor A should be y=10'); 85 85 - expect(actorA.y).toBe(0, 'Actor A should be y=0'); 86 86 - expect(actorB.x).toBe(20, 'Actor B should be x=20'); 87 87 - expect(actorB.y).toBe(0, 'Actor B should be y=0'); 86 86 + expect(actorA.pos.x).toBe(0, 'Actor A should be y=10'); 87 87 + expect(actorA.pos.y).toBe(0, 'Actor A should be y=0'); 88 88 + expect(actorB.pos.x).toBe(20, 'Actor B should be x=20'); 89 89 + expect(actorB.pos.y).toBe(0, 'Actor B should be y=0'); 88 90 expect(actorA.vel.x).toBe(0, 'Actor A should not be moving in x'); 89 91 expect(actorB.vel.x).toBe(0, 'Actor B should not be moving in x'); 90 92 actorA.vel.x = 10; 91 93 actorB.vel.x = -10; 92 92 - actorB.x = 19; 93 93 - actorA.collisionArea.recalc(); 94 94 - actorB.collisionArea.recalc(); 94 94 + actorB.pos.x = 19; 95 95 + actorA.body.collider.shape.recalc(); 96 96 + actorB.body.collider.shape.recalc(); 95 97 const cc = new ex.CollisionContact( 96 96 - actorA.collisionArea, 97 97 - actorB.collisionArea, 98 98 + actorA.body.collider, 99 99 + actorB.body.collider, 98 100 ex.Vector.Right.clone(), 99 101 new ex.Vector(10, 0), 100 102 ex.Vector.Right.clone() ··· 105 107 actorA.body.applyMtv(); 106 108 actorB.body.applyMtv(); 107 109 108 108 - expect(actorA.x).toBe(-0.5); 109 109 - expect(actorA.y).toBe(0); 110 110 + expect(actorA.pos.x).toBe(-0.5); 111 111 + expect(actorA.pos.y).toBe(0); 110 112 expect(actorA.vel.x).toBeLessThan(0); 111 113 expect(actorA.vel.y).toBe(0); 112 114 113 113 - expect(actorB.x).toBe(19.5); 114 114 - expect(actorB.y).toBe(0); 115 115 + expect(actorB.pos.x).toBe(19.5); 116 116 + expect(actorB.pos.y).toBe(0); 115 117 expect(actorB.vel.x).toBeGreaterThan(0); 116 118 expect(actorB.vel.y).toBe(0); 117 119 }); ··· 128 130 emittedB = true; 129 131 }); 130 132 131 131 - actorB.x = 19; 133 133 + actorB.pos.x = 19; 132 134 const cc = new ex.CollisionContact( 133 133 - actorA.collisionArea, 134 134 - actorB.collisionArea, 135 135 + actorA.body.collider, 136 136 + actorB.body.collider, 135 137 ex.Vector.Right.clone(), 136 138 new ex.Vector(10, 0), 137 139 ex.Vector.Right.clone()

+2 -62

src/spec/CollisionGroupSpec.ts

Reviewed

··· 12 12 actor1 = new ex.Actor(100, 100, 100, 100); 13 13 actor2 = new ex.Actor(100, 100, 100, 100); 14 14 // Setting actor collision types to passive otherwise they push each other around 15 15 - actor1.collisionType = ex.CollisionType.Passive; 16 16 - actor2.collisionType = ex.CollisionType.Passive; 15 15 + actor1.body.collider.type = ex.CollisionType.Passive; 16 16 + actor2.body.collider.type = ex.CollisionType.Passive; 17 17 18 18 scene.add(actor1); 19 19 scene.add(actor2); ··· 21 21 scene = new ex.Scene(engine); 22 22 engine.currentScene = scene; 23 23 }); 24 24 - /* 25 25 - it("does not effect actors without collision groupings", ()=>{ 26 26 - expect(actor1.collides(actor2)).not.toBe(ex.Side.None); 27 27 - expect(actor2.collides(actor1)).not.toBe(ex.Side.None); 28 28 - }); 29 29 - 30 30 - it("handler should fire only on collision with registered group", ()=>{ 31 31 - var collided = false; 32 32 - actor1.onCollidesWith('group', function(){ 33 33 - collided = true; 34 34 - }); 35 35 - 36 36 - // Ensure that the handler is not fired without collision groups 37 37 - expect(collided).toBe(false); 38 38 - scene.update(engine, 20); 39 39 - expect(collided).toBe(false); 40 40 - 41 41 - // Collision handler should fire 42 42 - actor2.addCollisionGroup('group'); 43 43 - expect(collided).toBe(false); 44 44 - scene.update(engine, 20); 45 45 - expect(collided).toBe(true); 46 46 - 47 47 - }); 48 48 - 49 49 - it("can fire with multiple handlers", ()=>{ 50 50 - var collided1 = false; 51 51 - var collided2 = false; 52 52 - actor1.onCollidesWith('group1', function(){ 53 53 - collided1 = true; 54 54 - }); 55 55 - actor1.onCollidesWith('group2', function(){ 56 56 - collided2 = true; 57 57 - }); 58 58 - 59 59 - actor2.addCollisionGroup('group1'); 60 60 - actor2.addCollisionGroup('group2'); 61 61 - 62 62 - expect(collided1).toBe(false); 63 63 - expect(collided2).toBe(false); 64 64 - 65 65 - scene.update(engine, 30); 66 66 - 67 67 - expect(collided1).toBe(true); 68 68 - expect(collided2).toBe(true); 69 69 - }); 70 70 - 71 71 - it("should pass back the collided actor in the callback", ()=>{ 72 72 - 73 73 - var actor = null; 74 74 - actor1.onCollidesWith('group', (a)=>{ 75 75 - actor = a; 76 76 - }); 77 77 - actor2.addCollisionGroup('group'); 78 78 - expect(actor).toBeFalsy(); 79 79 - 80 80 - scene.update(engine, 30); 81 81 - 82 82 - expect(actor).toBe(actor2); 83 83 - });*/ 84 24 });

+38 -38

src/spec/CollisionSpec.ts

Reviewed

··· 16 16 17 17 actor1 = new ex.Actor(0, 0, 10, 10); 18 18 actor2 = new ex.Actor(5, 5, 10, 10); 19 19 - actor1.collisionType = ex.CollisionType.Active; 20 20 - actor2.collisionType = ex.CollisionType.Active; 19 19 + actor1.body.collider.type = ex.CollisionType.Active; 20 20 + actor2.body.collider.type = ex.CollisionType.Active; 21 21 22 22 engine.start(); 23 23 engine.add(actor1); ··· 55 55 it('order of actors collision should not matter when an Active and Active Collision', () => { 56 56 const collisionTree = new ex.DynamicTreeCollisionBroadphase(); 57 57 58 58 - actor1.collisionType = ex.CollisionType.Active; 59 59 - actor2.collisionType = ex.CollisionType.Active; 58 58 + actor1.body.collider.type = ex.CollisionType.Active; 59 59 + actor2.body.collider.type = ex.CollisionType.Active; 60 60 collisionTree.track(actor1.body); 61 61 collisionTree.track(actor2.body); 62 62 63 63 - let pairs = collisionTree.broadphase([actor1, actor2], 200); 63 63 + let pairs = collisionTree.broadphase([actor1.body, actor2.body], 200); 64 64 65 65 expect(pairs.length).toBe(1); 66 66 67 67 - pairs = collisionTree.broadphase([actor2, actor1], 200); 67 67 + pairs = collisionTree.broadphase([actor2.body, actor1.body], 200); 68 68 69 69 expect(pairs.length).toBe(1); 70 70 }); ··· 72 72 it('order of actors collision should not matter when an Active and Passive Collision', () => { 73 73 const collisionTree = new ex.DynamicTreeCollisionBroadphase(); 74 74 75 75 - actor1.collisionType = ex.CollisionType.Active; 76 76 - actor2.collisionType = ex.CollisionType.Passive; 75 75 + actor1.body.collider.type = ex.CollisionType.Active; 76 76 + actor2.body.collider.type = ex.CollisionType.Passive; 77 77 collisionTree.track(actor1.body); 78 78 collisionTree.track(actor2.body); 79 79 80 80 - let pairs = collisionTree.broadphase([actor1, actor2], 200); 80 80 + let pairs = collisionTree.broadphase([actor1.body, actor2.body], 200); 81 81 82 82 expect(pairs.length).toBe(1); 83 83 84 84 - pairs = collisionTree.broadphase([actor2, actor1], 200); 84 84 + pairs = collisionTree.broadphase([actor2.body, actor1.body], 200); 85 85 86 86 expect(pairs.length).toBe(1); 87 87 }); ··· 89 89 it('order of actors collision should not matter when an Active and PreventCollision', () => { 90 90 const collisionTree = new ex.DynamicTreeCollisionBroadphase(); 91 91 92 92 - actor1.collisionType = ex.CollisionType.Active; 93 93 - actor2.collisionType = ex.CollisionType.PreventCollision; 92 92 + actor1.body.collider.type = ex.CollisionType.Active; 93 93 + actor2.body.collider.type = ex.CollisionType.PreventCollision; 94 94 collisionTree.track(actor1.body); 95 95 collisionTree.track(actor2.body); 96 96 97 97 - let pairs = collisionTree.broadphase([actor1, actor2], 200); 97 97 + let pairs = collisionTree.broadphase([actor1.body, actor2.body], 200); 98 98 99 99 expect(pairs.length).toBe(0); 100 100 101 101 - pairs = collisionTree.broadphase([actor2, actor1], 200); 101 101 + pairs = collisionTree.broadphase([actor2.body, actor1.body], 200); 102 102 103 103 expect(pairs.length).toBe(0); 104 104 }); ··· 106 106 it('order of actors collision should not matter when an Active and Fixed', () => { 107 107 const collisionTree = new ex.DynamicTreeCollisionBroadphase(); 108 108 109 109 - actor1.collisionType = ex.CollisionType.Active; 110 110 - actor2.collisionType = ex.CollisionType.Fixed; 109 109 + actor1.body.collider.type = ex.CollisionType.Active; 110 110 + actor2.body.collider.type = ex.CollisionType.Fixed; 111 111 collisionTree.track(actor1.body); 112 112 collisionTree.track(actor2.body); 113 113 114 114 - let pairs = collisionTree.broadphase([actor1, actor2], 200); 114 114 + let pairs = collisionTree.broadphase([actor1.body, actor2.body], 200); 115 115 116 116 expect(pairs.length).toBe(1); 117 117 118 118 - pairs = collisionTree.broadphase([actor2, actor1], 200); 118 118 + pairs = collisionTree.broadphase([actor2.body, actor1.body], 200); 119 119 120 120 expect(pairs.length).toBe(1); 121 121 }); ··· 123 123 it('order of actors collision should not matter when an Fixed and Fixed', () => { 124 124 const collisionTree = new ex.DynamicTreeCollisionBroadphase(); 125 125 126 126 - actor1.collisionType = ex.CollisionType.Fixed; 127 127 - actor2.collisionType = ex.CollisionType.Fixed; 126 126 + actor1.body.collider.type = ex.CollisionType.Fixed; 127 127 + actor2.body.collider.type = ex.CollisionType.Fixed; 128 128 collisionTree.track(actor1.body); 129 129 collisionTree.track(actor2.body); 130 130 131 131 - let pairs = collisionTree.broadphase([actor1, actor2], 200); 131 131 + let pairs = collisionTree.broadphase([actor1.body, actor2.body], 200); 132 132 133 133 expect(pairs.length).toBe(0); 134 134 135 135 - pairs = collisionTree.broadphase([actor2, actor1], 200); 135 135 + pairs = collisionTree.broadphase([actor2.body, actor1.body], 200); 136 136 137 137 expect(pairs.length).toBe(0); 138 138 }); ··· 149 149 actor2Collision++; 150 150 }); 151 151 152 152 - actor2.collisionType = ex.CollisionType.Passive; 152 152 + actor2.body.collider.type = ex.CollisionType.Passive; 153 153 154 154 for (let i = 0; i < 50; i++) { 155 155 loop.advance(100); ··· 183 183 it('should recognize when actor bodies are touching', () => { 184 184 let touching = false; 185 185 actor1.on('postupdate', function() { 186 186 - if (actor1.body.touching(actor2)) { 186 186 + if (actor1.body.collider.touching(actor2.body.collider)) { 187 187 touching = true; 188 188 } 189 189 }); ··· 199 199 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.RigidBody; 200 200 201 201 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 202 202 - activeBlock.collisionType = ex.CollisionType.Active; 202 202 + activeBlock.body.collider.type = ex.CollisionType.Active; 203 203 activeBlock.vel.x = 100; 204 204 engine.add(activeBlock); 205 205 206 206 const passiveBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 207 207 - passiveBlock.collisionType = ex.CollisionType.Passive; 207 207 + passiveBlock.body.collider.type = ex.CollisionType.Passive; 208 208 passiveBlock.vel.x = -100; 209 209 engine.add(passiveBlock); 210 210 ··· 233 233 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.RigidBody; 234 234 235 235 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 236 236 - activeBlock.collisionType = ex.CollisionType.Active; 236 236 + activeBlock.body.collider.type = ex.CollisionType.Active; 237 237 activeBlock.vel.x = 100; 238 238 engine.add(activeBlock); 239 239 240 240 const passiveBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 241 241 - passiveBlock.collisionType = ex.CollisionType.Passive; 241 241 + passiveBlock.body.collider.type = ex.CollisionType.Passive; 242 242 passiveBlock.vel.x = -100; 243 243 engine.add(passiveBlock); 244 244 ··· 261 261 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.RigidBody; 262 262 263 263 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 264 264 - activeBlock.collisionType = ex.CollisionType.Active; 264 264 + activeBlock.body.collider.type = ex.CollisionType.Active; 265 265 activeBlock.vel.x = 100; 266 266 engine.add(activeBlock); 267 267 268 268 const passiveBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 269 269 - passiveBlock.collisionType = ex.CollisionType.Passive; 269 269 + passiveBlock.body.collider.type = ex.CollisionType.Passive; 270 270 passiveBlock.vel.x = -100; 271 271 engine.add(passiveBlock); 272 272 ··· 289 289 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.Box; 290 290 291 291 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 292 292 - activeBlock.collisionType = ex.CollisionType.Active; 292 292 + activeBlock.body.collider.type = ex.CollisionType.Active; 293 293 activeBlock.vel.x = 100; 294 294 engine.add(activeBlock); 295 295 296 296 const fixedBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 297 297 - fixedBlock.collisionType = ex.CollisionType.Fixed; 297 297 + fixedBlock.body.collider.type = ex.CollisionType.Fixed; 298 298 engine.add(fixedBlock); 299 299 300 300 for (let i = 0; i < 20; i++) { ··· 308 308 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.Box; 309 309 310 310 const activeBlock = new ex.Actor(350, 200, 50, 50, ex.Color.Red.clone()); 311 311 - activeBlock.collisionType = ex.CollisionType.Active; 311 311 + activeBlock.body.collider.type = ex.CollisionType.Active; 312 312 engine.add(activeBlock); 313 313 314 314 const fixedBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 315 315 - fixedBlock.collisionType = ex.CollisionType.Fixed; 315 315 + fixedBlock.body.collider.type = ex.CollisionType.Fixed; 316 316 engine.add(fixedBlock); 317 317 318 318 activeBlock.vel.x = -100; ··· 328 328 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.RigidBody; 329 329 330 330 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 331 331 - activeBlock.collisionType = ex.CollisionType.Active; 331 331 + activeBlock.body.collider.type = ex.CollisionType.Active; 332 332 activeBlock.vel.x = 100; 333 333 engine.add(activeBlock); 334 334 335 335 const passiveBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 336 336 - passiveBlock.collisionType = ex.CollisionType.Passive; 336 336 + passiveBlock.body.collider.type = ex.CollisionType.Passive; 337 337 passiveBlock.vel.x = -100; 338 338 engine.add(passiveBlock); 339 339 ··· 353 353 ex.Physics.collisionResolutionStrategy = ex.CollisionResolutionStrategy.RigidBody; 354 354 355 355 const activeBlock = new ex.Actor(200, 200, 50, 50, ex.Color.Red.clone()); 356 356 - activeBlock.collisionType = ex.CollisionType.Active; 356 356 + activeBlock.body.collider.type = ex.CollisionType.Active; 357 357 activeBlock.vel.x = 100; 358 358 engine.add(activeBlock); 359 359 360 360 const passiveBlock = new ex.Actor(400, 200, 50, 50, ex.Color.DarkGray.clone()); 361 361 - passiveBlock.collisionType = ex.CollisionType.Passive; 361 361 + passiveBlock.body.collider.type = ex.CollisionType.Passive; 362 362 passiveBlock.vel.x = -100; 363 363 engine.add(passiveBlock); 364 364

+13 -13

src/spec/DynamicTreeBroadphaseSpec.ts

Reviewed

··· 7 7 8 8 beforeEach(() => { 9 9 actorA = new ex.Actor(0, 0, 20, 20); 10 10 - actorA.collisionType = ex.CollisionType.Active; 11 11 - actorA.collisionArea = new ex.CircleArea({ 12 12 - radius: 10, 13 13 - body: actorA.body 10 10 + const colliderA = actorA.body.collider; 11 11 + colliderA.type = ex.CollisionType.Active; 12 12 + colliderA.shape = new ex.Circle({ 13 13 + radius: 10 14 14 }); 15 15 16 16 actorB = new ex.Actor(20, 0, 20, 20); 17 17 - actorB.collisionType = ex.CollisionType.Active; 17 17 + const colliderB = actorB.body.collider; 18 18 + colliderB.type = ex.CollisionType.Active; 18 19 19 19 - actorB.collisionArea = new ex.CircleArea({ 20 20 - radius: 10, 21 21 - body: actorB.body 20 20 + colliderB.shape = new ex.Circle({ 21 21 + radius: 10 22 22 }); 23 23 24 24 actorC = new ex.Actor(1000, 0, 20, 20); 25 25 - actorC.collisionType = ex.CollisionType.Active; 25 25 + const colliderC = actorC.body.collider; 26 26 + colliderC.type = ex.CollisionType.Active; 26 27 27 27 - actorC.collisionArea = new ex.CircleArea({ 28 28 - radius: 10, 29 29 - body: actorC.body 28 28 + colliderC.shape = new ex.Circle({ 29 29 + radius: 10 30 30 }); 31 31 }); 32 32 ··· 47 47 dt.track(actorC.body); 48 48 49 49 // only should be 1 pair since C is very far away 50 50 - const pairs = dt.broadphase([actorA, actorB, actorC], 100); 50 50 + const pairs = dt.broadphase([actorA.body, actorB.body, actorC.body], 100); 51 51 52 52 expect(pairs.length).toBe(1); 53 53 });

+1 -2

src/spec/EngineSpec.ts

Reviewed

··· 67 67 engine.currentScene = scene; 68 68 engine.currentScene.add( 69 69 new ex.Actor({ 70 70 - x: 250, 71 71 - y: 250, 70 70 + pos: new ex.Vector(250, 250), 72 71 width: 20, 73 72 height: 20, 74 73 color: ex.Color.Red

-4

src/spec/EventSpec.ts

Reviewed

··· 66 66 expect(eventHistory).toEqual(subscriptions); 67 67 }); 68 68 69 69 - //it('can be subscribed to', () => { }); //TODO 70 70 - 71 71 - //it('can be unsubscribed from', () => { }); //TODO 72 72 - 73 69 it('can wire to other event dispatchers', () => { 74 70 const newPubSub = new ex.EventDispatcher(null); 75 71 pubsub.wire(newPubSub);

+11 -2

src/spec/GroupSpec.ts

Reviewed

··· 1 1 import * as ex from '../../build/dist/excalibur'; 2 2 import { Mocks } from './util/Mocks'; 3 3 4 4 + // @obsolete in v0.24.0 4 5 describe('An Actor Group', () => { 5 6 let engine: ex.Engine; 6 7 let scene: ex.Scene; ··· 38 39 expect(group.getMembers().length).toBe(2); 39 40 }); 40 41 42 42 + // @obsolete in v0.24.0 41 43 it('members ares automatically add to the scene', () => { 42 44 const actor = new ex.Actor(); 43 45 ··· 47 49 expect(scene.contains(actor)).toBeTruthy(); 48 50 }); 49 51 52 52 + // @obsolete in v0.24.0 50 53 it('can remove members', () => { 51 54 const actor = new ex.Actor(); 52 55 group.add(actor); ··· 57 60 expect(scene.contains(actor)).toBeTruthy(); 58 61 }); 59 62 63 63 + // @obsolete in v0.24.0 60 64 it('can aggregate events across multiple actors', () => { 61 65 let eventCount = 0; 62 66 // arrange ··· 79 83 expect(eventCount).toBe(3); 80 84 }); 81 85 82 82 - it('can return the containing bounding box of all members', () => { 86 86 + // @obsolete in v0.24.0 87 87 + xit('can return the containing bounding box of all members', () => { 83 88 const a1 = new ex.Actor(0, 0, 100, 100); 84 89 a1.anchor.setTo(0, 0); 85 90 const a2 = new ex.Actor(100, 100, 200, 190); ··· 91 96 expect(group.getBounds().getHeight()).toBe(290); 92 97 }); 93 98 94 94 - it('can get a random member', () => { 99 99 + // @obsolete in v0.24.0 100 100 + xit('can get a random member', () => { 95 101 // arrange 96 102 const a1 = new ex.Actor(); 97 103 const a2 = new ex.Actor(); ··· 104 110 expect(group.contains(ran)).toBeTruthy(); 105 111 }); 106 112 113 113 + // @obsolete in v0.24.0 107 114 it('can move many actors at once by a delta', () => { 108 115 const a1 = new ex.Actor(0, 0, 100, 100); 109 116 const a2 = new ex.Actor(100, 100, 200, 190); ··· 118 125 expect(a2.pos.y).toBe(110); 119 126 }); 120 127 128 128 + // @obsolete in v0.24.0 121 129 it('can rotate many actors at once by an angle', () => { 122 130 const a1 = new ex.Actor(0, 0, 100, 100); 123 131 a1.rotation = Math.PI / 3; ··· 131 139 expect(a2.rotation).toBeCloseTo((Math.PI * 5) / 6, 0.001); 132 140 }); 133 141 142 142 + // @obsolete in v0.24.0 134 143 it('can call actions off of actors', () => { 135 144 const a1 = new ex.Actor(0, 0, 100, 100); 136 145

+6 -8

src/spec/ParticleSpec.ts

Reviewed

··· 21 21 22 22 it('should have props set by the constructor', () => { 23 23 const emitter = new ex.ParticleEmitter({ 24 24 - x: 400, 25 25 - y: 100, 24 24 + pos: new ex.Vector(400, 100), 26 25 width: 20, 27 26 height: 30, 28 27 isEmitting: true, ··· 51 50 random: new ex.Random(1337) 52 51 }); 53 52 54 54 - expect(emitter.x).toBe(400); 55 55 - expect(emitter.y).toBe(100); 56 56 - expect(emitter.getWidth()).toBe(20); 57 57 - expect(emitter.getHeight()).toBe(30); 53 53 + expect(emitter.pos.x).toBe(400); 54 54 + expect(emitter.pos.y).toBe(100); 55 55 + expect(emitter.width).toBe(20); 56 56 + expect(emitter.height).toBe(30); 58 57 expect(emitter.isEmitting).toBe(true); 59 58 expect(emitter.minVel).toBe(40); 60 59 expect(emitter.maxVel).toBe(50); ··· 83 82 84 83 it('should emit particles', (done) => { 85 84 const emitter = new ex.ParticleEmitter({ 86 86 - x: 400, 87 87 - y: 100, 85 85 + pos: new ex.Vector(400, 100), 88 86 width: 20, 89 87 height: 30, 90 88 isEmitting: true,

+2 -2

src/spec/PointerInputSpec.ts

Reviewed

··· 116 116 }); 117 117 118 118 it('should not throw when checking if actors are under pointer if no pointer events have happened yet', () => { 119 119 - const actor = new ex.Actor({ x: 50, y: 50, width: 100, height: 100 }); 119 119 + const actor = new ex.Actor({ pos: new ex.Vector(50, 50), width: 100, height: 100 }); 120 120 expect(() => engine.input.pointers.primary.isActorUnderPointer(actor)).not.toThrowError(); 121 121 expect(engine.input.pointers.primary.isActorUnderPointer(actor)).toBe(false); 122 122 }); 123 123 124 124 it('should return true when an actor is under the pointer', () => { 125 125 - const actor = new ex.Actor({ x: 50, y: 50, width: 100, height: 100 }); 125 125 + const actor = new ex.Actor({ pos: new ex.Vector(50, 50), width: 100, height: 100 }); 126 126 executeMouseEvent('pointerdown', <any>document, null, 50, 50); 127 127 128 128 expect(engine.input.pointers.primary.isActorUnderPointer(actor)).toBe(true);

+1 -1

src/spec/ScaleSpec.ts

Reviewed

··· 14 14 15 15 actor = new ex.UIActor(50, 50, 100, 50); 16 16 actor.color = ex.Color.Blue; 17 17 - actor.collisionType = ex.CollisionType.Active; 17 17 + actor.body.collider.type = ex.CollisionType.Active; 18 18 engine = TestUtils.engine({ width: 800, height: 600 }); 19 19 engine.setAntialiasing(false); 20 20

+20 -20

src/spec/SceneSpec.ts

Reviewed

··· 50 50 actor.traits.push(new ex.Traits.OffscreenCulling()); 51 51 actor.pos.x = 0; 52 52 actor.pos.y = 0; 53 53 - actor.setWidth(10); 54 54 - actor.setHeight(10); 53 53 + actor.width = 10; 54 54 + actor.height = 10; 55 55 56 56 scene.add(actor); 57 57 scene.update(engine, 100); ··· 66 66 actor.traits.push(new ex.Traits.OffscreenCulling()); 67 67 actor.pos.x = -4; 68 68 actor.pos.y = 0; 69 69 - actor.setWidth(10); 70 70 - actor.setHeight(10); 69 69 + actor.width = 10; 70 70 + actor.height = 10; 71 71 72 72 scene.add(actor); 73 73 scene.update(engine, 100); ··· 81 81 actor.traits.push(new ex.Traits.OffscreenCulling()); 82 82 actor.pos.x = -6; 83 83 actor.pos.y = 0; 84 84 - actor.setWidth(10); 85 85 - actor.setHeight(10); 84 84 + actor.width = 10; 85 85 + actor.height = 10; 86 86 87 87 scene.add(actor); 88 88 scene.update(engine, 100); ··· 97 97 actor.traits.push(new ex.Traits.OffscreenCulling()); 98 98 actor.pos.x = 0; 99 99 actor.pos.y = -4; 100 100 - actor.setWidth(10); 101 101 - actor.setHeight(10); 100 100 + actor.width = 10; 101 101 + actor.height = 10; 102 102 103 103 scene.add(actor); 104 104 scene.update(engine, 100); ··· 113 113 actor.traits.push(new ex.Traits.OffscreenCulling()); 114 114 actor.pos.x = 0; 115 115 actor.pos.y = -6; 116 116 - actor.setWidth(10); 117 117 - actor.setHeight(10); 116 116 + actor.width = 10; 117 117 + actor.height = 10; 118 118 119 119 scene.add(actor); 120 120 scene.update(engine, 100); ··· 129 129 actor.traits.push(new ex.Traits.OffscreenCulling()); 130 130 actor.pos.x = 104; 131 131 actor.pos.y = 0; 132 132 - actor.setWidth(10); 133 133 - actor.setHeight(10); 132 132 + actor.width = 10; 133 133 + actor.height = 10; 134 134 135 135 scene.add(actor); 136 136 scene.update(engine, 100); ··· 145 145 actor.traits.push(new ex.Traits.OffscreenCulling()); 146 146 actor.pos.x = 106; 147 147 actor.pos.y = 0; 148 148 - actor.setWidth(10); 149 149 - actor.setHeight(10); 148 148 + actor.width = 10; 149 149 + actor.height = 10; 150 150 151 151 scene.add(actor); 152 152 scene.update(engine, 100); ··· 161 161 actor.traits.push(new ex.Traits.OffscreenCulling()); 162 162 actor.pos.x = 0; 163 163 actor.pos.y = 104; 164 164 - actor.setWidth(10); 165 165 - actor.setHeight(10); 164 164 + actor.width = 10; 165 165 + actor.height = 10; 166 166 167 167 scene.add(actor); 168 168 scene.update(engine, 100); ··· 177 177 actor.traits.push(new ex.Traits.OffscreenCulling()); 178 178 actor.pos.x = 0; 179 179 actor.pos.y = 106; 180 180 - actor.setWidth(10); 181 181 - actor.setHeight(10); 180 180 + actor.width = 10; 181 181 + actor.height = 10; 182 182 183 183 scene.add(actor); 184 184 scene.update(engine, 100); ··· 196 196 197 197 actor.pos.x = 1010; 198 198 actor.pos.y = 1010; 199 199 - actor.setWidth(5); 200 200 - actor.setHeight(5); 199 199 + actor.width = 5; 200 200 + actor.height = 5; 201 201 202 202 scene.add(actor); 203 203 scene.update(engine, 100);

+2 -2

src/spec/TimescalingSpec.ts

Reviewed

··· 33 33 // actor moves twice as fast 34 34 loop.advance(1100); 35 35 36 36 - expect(actor.x).toBe(10, 'actor did not move twice as fast'); 36 36 + expect(actor.pos.x).toBe(10, 'actor did not move twice as fast'); 37 37 }); 38 38 39 39 it('should run at 1/2 speed when timescale is 0.5', () => { ··· 47 47 // actor moves twice as slow 48 48 loop.advance(2000); 49 49 50 50 - expect(actor.x).toBeCloseTo(5, 0.2, 'actor did not move twice as slow'); 50 50 + expect(actor.pos.x).toBeCloseTo(5, 0.2, 'actor did not move twice as slow'); 51 51 }); 52 52 });

+6 -6

src/spec/TriggerSpec.ts

Reviewed

··· 35 35 repeat: 1 36 36 }); 37 37 const actor = new ex.Actor(0, 0, 10, 10); 38 38 - actor.collisionType = ex.CollisionType.Active; 38 38 + actor.body.collider.type = ex.CollisionType.Active; 39 39 actor.vel.y = 10; 40 40 engine.currentScene.add(trigger); 41 41 engine.currentScene.add(actor); ··· 70 70 repeat: 3 71 71 }); 72 72 const actor = new ex.Actor(0, 0, 10, 10); 73 73 - actor.collisionType = ex.CollisionType.Active; 73 73 + actor.body.collider.type = ex.CollisionType.Active; 74 74 actor.vel.y = 10; 75 75 engine.currentScene.add(trigger); 76 76 engine.currentScene.add(actor); ··· 106 106 height: 100 107 107 }); 108 108 109 109 - trigger.collisionType = ex.CollisionType.Passive; 109 109 + trigger.body.collider.type = ex.CollisionType.Passive; 110 110 111 111 const actor = new ex.Actor(0, 0, 10, 10); 112 112 - actor.collisionType = ex.CollisionType.Active; 112 112 + actor.body.collider.type = ex.CollisionType.Active; 113 113 actor.vel.y = 10; 114 114 115 115 trigger.on('collisionstart', (evt: ex.EnterTriggerEvent) => { ··· 139 139 }); 140 140 141 141 const actor = new ex.Actor(0, 0, 10, 10); 142 142 - actor.collisionType = ex.CollisionType.Active; 142 142 + actor.body.collider.type = ex.CollisionType.Active; 143 143 actor.vel.y = 10; 144 144 145 145 engine.add(trigger); ··· 236 236 }); 237 237 238 238 const actor = new ex.Actor(0, 100, 10, 10); 239 239 - actor.collisionType = ex.CollisionType.Active; 239 239 + actor.body.collider.type = ex.CollisionType.Active; 240 240 241 241 engine.add(trigger); 242 242 engine.add(actor);

+3 -4

src/spec/UIActorSpec.ts

Reviewed

··· 13 13 jasmine.addMatchers(ExcaliburMatchers); 14 14 15 15 uiActor = new ex.UIActor({ 16 16 - x: 50, 17 17 - y: 50, 16 16 + pos: new ex.Vector(50, 50), 18 17 width: 100, 19 18 height: 50, 20 20 - color: ex.Color.Blue, 21 21 - collisionType: ex.CollisionType.Active 19 19 + color: ex.Color.Blue 22 20 }); 21 21 + uiActor.body.collider.type = ex.CollisionType.Active; 23 22 engine = TestUtils.engine(); 24 23 25 24 scene = new ex.Scene(engine);

src/spec/images/CollisionShapeSpec/circle.png

Reviewed

This is a binary file and will not be displayed.

src/spec/images/CollisionShapeSpec/edge.png

Reviewed

This is a binary file and will not be displayed.

src/spec/images/CollisionShapeSpec/triangle.png

Reviewed

This is a binary file and will not be displayed.