CocosPlugin/esengine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/esengine/egret-framework

Browse Source 
# Conflicts:
#	demo/libs/framework/framework.d.ts
#	demo/libs/framework/framework.min.js
#	demo/src/game/MainScene.ts
#	source/bin/framework.d.ts
#	source/bin/framework.min.js
This commit is contained in:
YHH
2020-07-12 09:46:07 +08:00
parent 3f6ab79894 20392c8ab6
commit d9bb76c105
53 changed files with 2656 additions and 1222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
demo/index.html
View File

@@ -27,7 +27,7 @@
data-entry-class="Main"
data-orientation="auto"
data-scale-mode="fixedWidth"
data-frame-rate="30"
data-frame-rate="60"
data-content-width="640"
data-content-height="1136"
data-multi-fingered="2"

293
demo/libs/framework/framework.d.ts vendored
View File

@@ -32,22 +32,22 @@ declare class AStarNode<T> extends PriorityQueueNode {
data: T;
constructor(data: T);
}
declare class AstarGridGraph implements IAstarGraph<Point> {
dirs: Point[];
walls: Point[];
weightedNodes: Point[];
declare class AstarGridGraph implements IAstarGraph<Vector2> {
dirs: Vector2[];
walls: Vector2[];
weightedNodes: Vector2[];
defaultWeight: number;
weightedNodeWeight: number;
private _width;
private _height;
private _neighbors;
constructor(width: number, height: number);
isNodeInBounds(node: Point): boolean;
isNodePassable(node: Point): boolean;
search(start: Point, goal: Point): Point[];
getNeighbors(node: Point): Point[];
cost(from: Point, to: Point): number;
heuristic(node: Point, goal: Point): number;
isNodeInBounds(node: Vector2): boolean;
isNodePassable(node: Vector2): boolean;
search(start: Vector2, goal: Vector2): Vector2[];
getNeighbors(node: Vector2): Vector2[];
cost(from: Vector2, to: Vector2): number;
heuristic(node: Vector2, goal: Vector2): number;
}
interface IAstarGraph<T> {
getNeighbors(node: T): Array<T>;
@@ -61,6 +61,7 @@ declare class PriorityQueue<T extends PriorityQueueNode> {
constructor(maxNodes: number);
clear(): void;
readonly count: number;
readonly maxSize: number;
contains(node: T): boolean;
enqueue(node: T, priority: number): void;
dequeue(): T;
@@ -84,34 +85,57 @@ declare class UnweightedGraph<T> implements IUnweightedGraph<T> {
addEdgesForNode(node: T, edges: T[]): this;
getNeighbors(node: T): T[];
}
declare class Point {
declare class Vector2 {
x: number;
y: number;
private static readonly unitYVector;
private static readonly unitXVector;
private static readonly unitVector2;
private static readonly zeroVector2;
static readonly zero: Vector2;
static readonly one: Vector2;
static readonly unitX: Vector2;
static readonly unitY: Vector2;
constructor(x?: number, y?: number);
static add(value1: Vector2, value2: Vector2): Vector2;
static divide(value1: Vector2, value2: Vector2): Vector2;
static multiply(value1: Vector2, value2: Vector2): Vector2;
static subtract(value1: Vector2, value2: Vector2): Vector2;
normalize(): void;
length(): number;
round(): Vector2;
static normalize(value: Vector2): Vector2;
static dot(value1: Vector2, value2: Vector2): number;
static distanceSquared(value1: Vector2, value2: Vector2): number;
static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
static transform(position: Vector2, matrix: Matrix2D): Vector2;
static distance(value1: Vector2, value2: Vector2): number;
static negate(value: Vector2): Vector2;
}
declare class UnweightedGridGraph implements IUnweightedGraph<Point> {
declare class UnweightedGridGraph implements IUnweightedGraph<Vector2> {
private static readonly CARDINAL_DIRS;
private static readonly COMPASS_DIRS;
walls: Point[];
walls: Vector2[];
private _width;
private _hegiht;
private _dirs;
private _neighbors;
constructor(width: number, height: number, allowDiagonalSearch?: boolean);
isNodeInBounds(node: Point): boolean;
isNodePassable(node: Point): boolean;
getNeighbors(node: Point): Point[];
search(start: Point, goal: Point): Point[];
isNodeInBounds(node: Vector2): boolean;
isNodePassable(node: Vector2): boolean;
getNeighbors(node: Vector2): Vector2[];
search(start: Vector2, goal: Vector2): Vector2[];
}
interface IWeightedGraph<T> {
getNeighbors(node: T): T[];
cost(from: T, to: T): number;
}
declare class WeightedGridGraph implements IWeightedGraph<Point> {
static readonly CARDINAL_DIRS: Point[];
declare class WeightedGridGraph implements IWeightedGraph<Vector2> {
static readonly CARDINAL_DIRS: Vector2[];
private static readonly COMPASS_DIRS;
walls: Point[];
weightedNodes: Point[];
walls: Vector2[];
weightedNodes: Vector2[];
defaultWeight: number;
weightedNodeWeight: number;
private _width;
@@ -119,11 +143,11 @@ declare class WeightedGridGraph implements IWeightedGraph<Point> {
private _dirs;
private _neighbors;
constructor(width: number, height: number, allowDiagonalSearch?: boolean);
isNodeInBounds(node: Point): boolean;
isNodePassable(node: Point): boolean;
search(start: Point, goal: Point): Point[];
getNeighbors(node: Point): Point[];
cost(from: Point, to: Point): number;
isNodeInBounds(node: Vector2): boolean;
isNodePassable(node: Vector2): boolean;
search(start: Vector2, goal: Vector2): Vector2[];
getNeighbors(node: Vector2): Vector2[];
cost(from: Vector2, to: Vector2): number;
}
declare class WeightedNode<T> extends PriorityQueueNode {
data: T;
@@ -135,30 +159,58 @@ declare class WeightedPathfinder {
private static getKey;
static recontructPath<T>(cameFrom: Map<T, T>, start: T, goal: T): T[];
}
declare class Debug {
private static _debugDrawItems;
static drawHollowRect(rectanle: Rectangle, color: number, duration?: number): void;
static render(): void;
}
declare class DebugDefaults {
static verletParticle: number;
static verletConstraintEdge: number;
}
declare enum DebugDrawType {
line = 0,
hollowRectangle = 1,
pixel = 2,
text = 3
}
declare class DebugDrawItem {
rectangle: Rectangle;
color: number;
duration: number;
drawType: DebugDrawType;
text: string;
start: Vector2;
end: Vector2;
x: number;
y: number;
size: number;
constructor(rectangle: Rectangle, color: number, duration: number);
draw(shape: egret.Shape): boolean;
}
declare abstract class Component extends egret.DisplayObjectContainer {
entity: Entity;
private _enabled;
updateInterval: number;
userData: any;
private _updateOrder;
enabled: boolean;
readonly localPosition: Vector2;
setEnabled(isEnabled: boolean): this;
updateOrder: number;
setUpdateOrder(updateOrder: number): this;
initialize(): void;
onAddedToEntity(): void;
onRemovedFromEntity(): void;
onEnabled(): void;
onDisabled(): void;
update(): void;
debugRender(): void;
onEntityTransformChanged(comp: TransformComponent): void;
registerComponent(): void;
deregisterComponent(): void;
}
declare class Entity extends egret.DisplayObjectContainer {
private static _idGenerator;
private _position;
name: string;
readonly id: number;
scene: Scene;
@@ -171,11 +223,13 @@ declare class Entity extends egret.DisplayObjectContainer {
readonly isDestoryed: boolean;
position: Vector2;
scale: Vector2;
rotation: number;
enabled: boolean;
setEnabled(isEnabled: boolean): this;
tag: number;
readonly stage: egret.Stage;
constructor(name: string);
private onAddToStage;
updateOrder: number;
roundPosition(): void;
setUpdateOrder(updateOrder: number): this;
@@ -187,6 +241,7 @@ declare class Entity extends egret.DisplayObjectContainer {
getOrCreateComponent<T extends Component>(type: T): T;
getComponent<T extends Component>(type: any): T;
getComponents(typeName: string | any, componentList?: any): any;
private onEntityTransformChanged;
removeComponentForType<T extends Component>(type: any): boolean;
removeComponent(component: Component): void;
removeAllComponents(): void;
@@ -195,6 +250,16 @@ declare class Entity extends egret.DisplayObjectContainer {
onRemovedFromScene(): void;
destroy(): void;
}
declare enum TransformComponent {
rotation = 0,
scale = 1,
position = 2
}
interface IUpdatable {
enabled: boolean;
updateOrder: number;
update(): any;
}
declare class Scene extends egret.DisplayObjectContainer {
camera: Camera;
readonly entities: EntityList;
@@ -239,11 +304,12 @@ declare class SceneManager {
static render(): void;
static startSceneTransition<T extends SceneTransition>(sceneTransition: T): T;
}
declare class Camera extends Component {
declare class Camera extends Component implements IUpdatable {
private _zoom;
private _origin;
private _minimumZoom;
private _maximumZoom;
private _position;
followLerp: number;
deadzone: Rectangle;
focusOffset: Vector2;
@@ -259,6 +325,8 @@ declare class Camera extends Component {
maximumZoom: number;
origin: Vector2;
position: Vector2;
x: number;
y: number;
constructor();
onSceneSizeChanged(newWidth: number, newHeight: number): void;
setMinimumZoom(minZoom: number): Camera;
@@ -311,36 +379,6 @@ declare class Mesh extends RenderableComponent {
render(camera: Camera): void;
reset(): void;
}
declare class SpriteRenderer extends RenderableComponent {
private _origin;
private _sprite;
protected bitmap: egret.Bitmap;
origin: Vector2;
setOrigin(origin: Vector2): this;
sprite: Sprite;
setSprite(sprite: Sprite): SpriteRenderer;
setColor(color: number): SpriteRenderer;
isVisibleFromCamera(camera: Camera): boolean;
render(camera: Camera): void;
onRemovedFromEntity(): void;
reset(): void;
}
declare class TiledSpriteRenderer extends SpriteRenderer {
protected sourceRect: Rectangle;
protected leftTexture: egret.Bitmap;
protected rightTexture: egret.Bitmap;
scrollX: number;
scrollY: number;
constructor(sprite: Sprite);
render(camera: Camera): void;
}
declare class ScrollingSpriteRenderer extends TiledSpriteRenderer {
scrollSpeedX: number;
scroolSpeedY: number;
private _scrollX;
private _scrollY;
update(): void;
}
declare class Sprite {
texture2D: egret.Texture;
readonly sourceRect: Rectangle;
@@ -354,7 +392,18 @@ declare class SpriteAnimation {
readonly frameRate: number;
constructor(sprites: Sprite[], frameRate: number);
}
declare class SpriteAnimator extends SpriteRenderer {
declare class SpriteRenderer extends RenderableComponent {
private _sprite;
protected bitmap: egret.Bitmap;
sprite: Sprite;
setSprite(sprite: Sprite): SpriteRenderer;
setColor(color: number): SpriteRenderer;
isVisibleFromCamera(camera: Camera): boolean;
render(camera: Camera): void;
onRemovedFromEntity(): void;
reset(): void;
}
declare class SpriteAnimator extends SpriteRenderer implements IUpdatable {
onAnimationCompletedEvent: Function;
speed: number;
animationState: State;
@@ -387,6 +436,13 @@ declare enum State {
paused = 2,
completed = 3
}
declare class TiledSpriteRenderer extends SpriteRenderer {
protected sourceRect: Rectangle;
scrollX: number;
scrollY: number;
constructor(sprite: Sprite);
render(camera: Camera): void;
}
interface ITriggerListener {
onTriggerEnter(other: Collider, local: Collider): any;
onTriggerExit(other: Collider, local: Collider): any;
@@ -394,20 +450,21 @@ interface ITriggerListener {
declare class Mover extends Component {
private _triggerHelper;
onAddedToEntity(): void;
calculateMovement(motion: Vector2): CollisionResult;
calculateMovement(motion: Vector2): {
collisionResult: CollisionResult;
motion: Vector2;
};
applyMovement(motion: Vector2): void;
move(motion: Vector2): CollisionResult;
}
declare abstract class Collider extends Component {
declare abstract class Collider extends Component implements IUpdatable {
shape: Shape;
physicsLayer: number;
isTrigger: boolean;
registeredPhysicsBounds: Rectangle;
shouldColliderScaleAndRotationWithTransform: boolean;
shouldColliderScaleAndRotateWithTransform: boolean;
collidesWithLayers: number;
_localOffsetLength: number;
_isPositionDirty: boolean;
_isRotationDirty: boolean;
protected _isParentEntityAddedToScene: any;
protected _colliderRequiresAutoSizing: any;
protected _localOffset: Vector2;
@@ -423,6 +480,8 @@ declare abstract class Collider extends Component {
onRemovedFromEntity(): void;
onEnabled(): void;
onDisabled(): void;
onEntityTransformChanged(comp: TransformComponent): void;
update(): void;
}
declare class BoxCollider extends Collider {
width: number;
@@ -432,6 +491,14 @@ declare class BoxCollider extends Collider {
constructor();
setSize(width: number, height: number): this;
}
declare class CircleCollider extends Collider {
radius: number;
constructor(radius?: number);
setRadius(radius: number): CircleCollider;
}
declare class PolygonCollider extends Collider {
constructor(points: Vector2[]);
}
declare class EntitySystem {
private _scene;
private _entities;
@@ -488,6 +555,7 @@ declare class ComponentList {
private _components;
private _componentsToAdd;
private _componentsToRemove;
private _updatableComponents;
private _tempBufferList;
constructor(entity: Entity);
readonly count: number;
@@ -498,6 +566,7 @@ declare class ComponentList {
deregisterAllComponents(): void;
registerAllComponents(): void;
updateLists(): void;
onEntityTransformChanged(comp: TransformComponent): void;
private handleRemove;
getComponent<T extends Component>(type: any, onlyReturnInitializedComponents: boolean): T;
getComponents(typeName: string | any, components?: any): any;
@@ -677,7 +746,7 @@ declare abstract class SceneTransition {
onBeginTransition(): Promise<void>;
protected transitionComplete(): void;
protected loadNextScene(): Promise<void>;
tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<{}>;
tickEffectProgressProperty(filter: egret.CustomFilter, duration: number, easeType: Function, reverseDirection?: boolean): Promise<boolean>;
}
declare class FadeTransition extends SceneTransition {
fadeToColor: number;
@@ -719,6 +788,7 @@ declare class MathHelper {
static clamp(value: number, min: number, max: number): number;
static pointOnCirlce(circleCenter: Vector2, radius: number, angleInDegrees: number): Vector2;
static isEven(value: number): boolean;
static angleBetweenVectors(from: Vector2, to: Vector2): number;
}
declare class Matrix2D {
m11: number;
@@ -740,66 +810,28 @@ declare class Matrix2D {
static multiplyTranslation(matrix: Matrix2D, x: number, y: number): Matrix2D;
determinant(): number;
static invert(matrix: Matrix2D, result?: Matrix2D): Matrix2D;
static createTranslation(xPosition: number, yPosition: number, result?: Matrix2D): Matrix2D;
static createTranslation(xPosition: number, yPosition: number): Matrix2D;
static createTranslationVector(position: Vector2): Matrix2D;
static createRotation(radians: number, result?: Matrix2D): Matrix2D;
static createScale(xScale: number, yScale: number, result?: Matrix2D): Matrix2D;
toEgretMatrix(): egret.Matrix;
}
declare class Rectangle {
x: number;
y: number;
width: number;
height: number;
private _tempMat;
private _transformMat;
readonly left: number;
readonly right: number;
readonly top: number;
readonly bottom: number;
declare class Rectangle extends egret.Rectangle {
readonly max: Vector2;
readonly center: Vector2;
location: Vector2;
size: Vector2;
constructor(x?: number, y?: number, width?: number, height?: number);
intersects(value: Rectangle): boolean;
contains(value: Vector2): boolean;
intersects(value: egret.Rectangle): boolean;
containsRect(value: Rectangle): boolean;
getHalfSize(): Vector2;
static fromMinMax(minX: number, minY: number, maxX: number, maxY: number): Rectangle;
getClosestPointOnRectangleBorderToPoint(point: Point): {
getClosestPointOnRectangleBorderToPoint(point: Vector2): {
res: Vector2;
edgeNormal: Vector2;
};
calculateBounds(parentPosition: Vector2, position: Vector2, origin: Vector2, scale: Vector2, rotation: number, width: number, height: number): void;
getClosestPointOnBoundsToOrigin(): Vector2;
static rectEncompassingPoints(points: Vector2[]): Rectangle;
}
declare class Vector2 {
x: number;
y: number;
private static readonly unitYVector;
private static readonly unitXVector;
private static readonly unitVector2;
private static readonly zeroVector2;
static readonly zero: Vector2;
static readonly one: Vector2;
static readonly unitX: Vector2;
static readonly unitY: Vector2;
constructor(x?: number, y?: number);
static add(value1: Vector2, value2: Vector2): Vector2;
static divide(value1: Vector2, value2: Vector2): Vector2;
static multiply(value1: Vector2, value2: Vector2): Vector2;
static subtract(value1: Vector2, value2: Vector2): Vector2;
normalize(): void;
length(): number;
round(): Vector2;
static normalize(value: Vector2): Vector2;
static dot(value1: Vector2, value2: Vector2): number;
static distanceSquared(value1: Vector2, value2: Vector2): number;
static clamp(value1: Vector2, min: Vector2, max: Vector2): Vector2;
static lerp(value1: Vector2, value2: Vector2, amount: number): Vector2;
static transform(position: Vector2, matrix: Matrix2D): Vector2;
static distance(value1: Vector2, value2: Vector2): number;
static negate(value: Vector2): Vector2;
}
declare class Vector3 {
x: number;
y: number;
@@ -846,16 +878,23 @@ declare class Physics {
static reset(): void;
static clear(): void;
static overlapCircleAll(center: Vector2, randius: number, results: any[], layerMask?: number): number;
static boxcastBroadphase(rect: Rectangle, layerMask?: number): Collider[];
static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): Collider[];
static boxcastBroadphase(rect: Rectangle, layerMask?: number): {
colliders: Collider[];
rect: Rectangle;
};
static boxcastBroadphaseExcludingSelf(collider: Collider, rect: Rectangle, layerMask?: number): {
tempHashSet: Collider[];
bounds: Rectangle;
};
static addCollider(collider: Collider): void;
static removeCollider(collider: Collider): void;
static updateCollider(collider: Collider): void;
static debugDraw(secondsToDisplay: any): void;
}
declare abstract class Shape {
bounds: Rectangle;
position: Vector2;
center: Vector2;
abstract center: Vector2;
abstract recalculateBounds(collider: Collider): any;
abstract pointCollidesWithShape(point: Vector2): CollisionResult;
abstract overlaps(other: Shape): any;
@@ -867,6 +906,7 @@ declare class Polygon extends Shape {
private _polygonCenter;
private _areEdgeNormalsDirty;
protected _originalPoints: Vector2[];
center: Vector2;
_edgeNormals: Vector2[];
readonly edgeNormals: Vector2[];
isBox: boolean;
@@ -877,6 +917,7 @@ declare class Polygon extends Shape {
recalculateCenterAndEdgeNormals(): void;
overlaps(other: Shape): any;
static findPolygonCenter(points: Vector2[]): Vector2;
static recenterPolygonVerts(points: Vector2[]): void;
static getClosestPointOnPolygonToPoint(points: Vector2[], point: Vector2): {
closestPoint: any;
distanceSquared: any;
@@ -892,12 +933,15 @@ declare class Box extends Polygon {
height: number;
constructor(width: number, height: number);
private static buildBox;
overlaps(other: Shape): any;
collidesWithShape(other: Shape): any;
updateBox(width: number, height: number): void;
containsPoint(point: Vector2): boolean;
}
declare class Circle extends Shape {
radius: number;
private _originalRadius;
_originalRadius: number;
center: Vector2;
constructor(radius: number);
pointCollidesWithShape(point: Vector2): CollisionResult;
collidesWithShape(other: Shape): CollisionResult;
@@ -924,6 +968,8 @@ declare class ShapeCollisions {
static closestPointOnLine(lineA: Vector2, lineB: Vector2, closestTo: Vector2): Vector2;
static pointToPoly(point: Vector2, poly: Polygon): CollisionResult;
static circleToCircle(first: Circle, second: Circle): CollisionResult;
static boxToBox(first: Box, second: Box): CollisionResult;
private static minkowskiDifference;
}
declare class SpatialHash {
gridBounds: Rectangle;
@@ -938,9 +984,14 @@ declare class SpatialHash {
register(collider: Collider): void;
clear(): void;
overlapCircle(circleCenter: Vector2, radius: number, results: Collider[], layerMask: any): number;
aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): Collider[];
aabbBroadphase(bounds: Rectangle, excludeCollider: Collider, layerMask: number): {
tempHashSet: Collider[];
bounds: Rectangle;
};
private cellAtPosition;
private cellCoords;
debugDraw(secondsToDisplay: number, textScale?: number): void;
private debugDrawCellDetails;
}
declare class RaycastResultParser {
}
@@ -960,6 +1011,13 @@ declare class ContentManager {
loadRes(name: string, local?: boolean): Promise<any>;
dispose(): void;
}
declare class DrawUtils {
static drawLine(shape: egret.Shape, start: Vector2, end: Vector2, color: number, thickness?: number): void;
static drawLineAngle(shape: egret.Shape, start: Vector2, radians: number, length: number, color: number, thickness?: number): void;
static drawHollowRect(shape: egret.Shape, rect: Rectangle, color: number, thickness?: number): void;
static drawHollowRectR(shape: egret.Shape, x: number, y: number, width: number, height: number, color: number, thickness?: number): void;
static drawPixel(shape: egret.Shape, position: Vector2, color: number, size?: number): void;
}
declare class Emitter<T> {
private _messageTable;
constructor();
@@ -1026,8 +1084,7 @@ declare class Pair<T> {
equals(other: Pair<T>): boolean;
}
declare class RectangleExt {
static union(first: Rectangle, point: Point): Rectangle;
static unionR(value1: Rectangle, value2: Rectangle): Rectangle;
static union(first: Rectangle, point: Vector2): Rectangle;
}
declare class Triangulator {
triangleIndices: number[];

913
demo/libs/framework/framework.js
View File

File diff suppressed because it is too large Load Diff

2
demo/libs/framework/framework.min.js vendored
View File

File diff suppressed because one or more lines are too long

29
demo/src/game/MainScene.ts
View File

@@ -18,11 +18,11 @@ class MainScene extends Scene {
// bg.addComponent(new BoxCollider());
bg.position = new Vector2(Math.random() * 200, Math.random() * 200);
for (let i = 0; i < 100; i++) {
for (let i = 0; i < 20; i++) {
let sprite = new Sprite(RES.getRes("checkbox_select_disabled_png"));
let player2 = this.createEntity("player2");
player2.addComponent(new SpriteRenderer()).setSprite(sprite);
player2.position = new Vector2(Math.random() * 100 * i, Math.random() * 100 * i);
player2.position = new Vector2(Math.random() * 1000, Math.random() * 1000);
player2.addComponent(new BoxCollider());
}
@@ -64,24 +64,25 @@ class MainScene extends Scene {
public dijkstraTest() {
let graph = new WeightedGridGraph(20, 20);
graph.weightedNodes.push(new Point(3, 3));
graph.weightedNodes.push(new Point(3, 4));
graph.weightedNodes.push(new Point(4, 3));
graph.weightedNodes.push(new Point(4, 4));
graph.weightedNodes.push(new Vector2(3, 3));
graph.weightedNodes.push(new Vector2(3, 4));
graph.weightedNodes.push(new Vector2(4, 3));
graph.weightedNodes.push(new Vector2(4, 4));
let path = graph.search(new Point(3, 4), new Point(15, 17));
let path = graph.search(new Vector2(3, 4), new Vector2(15, 17));
console.log(path);
}
public astarTest() {
let graph = new AstarGridGraph(20, 20);
let graph = new AstarGridGraph(30, 30);
graph.weightedNodes.push(new Point(3, 3));
graph.weightedNodes.push(new Point(3, 4));
graph.weightedNodes.push(new Point(4, 3));
graph.weightedNodes.push(new Point(4, 4));
// graph.weightedNodes.push(new Vector2(3, 3));
// graph.weightedNodes.push(new Vector2(3, 4));
// graph.weightedNodes.push(new Vector2(4, 3));
// graph.weightedNodes.push(new Vector2(4, 4));
let path = graph.search(new Point(3, 4), new Point(15, 17));
console.log(path);
let startTime = egret.getTimer();
let path = graph.search(new Vector2(1, 1), new Vector2(29, 29));
console.log(egret.getTimer() - startTime);
}
}

10
demo/src/game/PlayerController.ts
View File

@@ -37,17 +37,17 @@ class PlayerController extends Component {
let camera = SceneManager.scene.camera;
let moveLeft: number = 0;
let moveRight: number = 0;
let speed = 200;
let speed = 100;
let worldPos = Input.touchPosition;
if (worldPos.x < this.spriteRenderer.x){
if (worldPos.x < this.spriteRenderer.localPosition.x){
moveLeft = -1;
} else if(worldPos.x > this.spriteRenderer.x){
} else if(worldPos.x > this.spriteRenderer.localPosition.x){
moveLeft = 1;
}
if (worldPos.y < this.spriteRenderer.y){
if (worldPos.y < this.spriteRenderer.localPosition.y){
moveRight = -1;
} else if(worldPos.y > this.spriteRenderer.y){
} else if(worldPos.y > this.spriteRenderer.localPosition.y){
moveRight = 1;
}
this.mover.move(new Vector2(moveLeft * speed * Time.deltaTime, moveRight * speed * Time.deltaTime));

2
demo/template/runtime/native_require.js
View File

@@ -32,7 +32,7 @@ egret_native.egretStart = function () {
//The following is automatically modified, please do not modify
//----auto option start----
entryClassName: "Main",
frameRate: 30,
frameRate: 60,
scaleMode: "fixedWidth",
contentWidth: 640,
contentHeight: 1136,