CocosCreator-Tutorial für den Einstieg: Erstellen Sie Ihr erstes Spiel mit TS

// - [Englisch] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/typescript/index.html
// Attribut lernen:
// - [Chinesisch] http://www.cocos.com/docs/creator/scripting/reference/attributes.html
// - [Englisch] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/reference/attributes/index.html
// Erfahren Sie mehr über Lebenszyklus-Rückrufe:
// - [Chinesisch] http://www.cocos.com/docs/creator/scripting/life-cycle-callbacks.html
// - [Englisch] http://www.cocos2d-x.org/docs/editors_and_tools/creator-chapters/scripting/life-cycle-callbacks/index.html

const {ccclass, Eigenschaft} = cc._decorator;

@ccklasse
exportiere Standardklasse NewClass erweitert cc.Component {

    @Eigenschaft(cc.Label)
    Bezeichnung: cc.Label = null;

    @Eigentum
    Text: Zeichenfolge = „Hallo“;

    // LEBENSZYKLUS-RÜCKRUFE:

    // beim Laden () {},

    Start () {

    },

    // aktualisieren (dt) {},
}

const {ccclass, Eigenschaft} = cc._decorator;

@ccklasse
Exportklasse NewClass erweitert cc.Component {

}

const LEVEL = cc.Enum({EASY:1,HARD:2});

@ccklasse
Exportklasse Game erweitert cc.Component {
    // Ganzzahl @Eigenschaft (cc.Integer)
    intVar: Zahl = 0;
    // Gleitkommatyp @property(cc.Float)
    FloatVar: Zahl = 0;
    // Boolesche @Eigenschaft (cc.Boolean)
    boolVar: boolean = false;
    // Knoten@Eigenschaft(cc.Node)
    KnotenVar: cc.Node = null;
    // Knoten-Array @property([cc.Node])
    nodeArrVar: Array<cc.Node> = [];
    // Etikett
    @Eigenschaft(cc.Label)
    Bezeichnungsvariable: cc.Label = null;
    // Fertighaus @property(cc.Prefab)
    prefabVar: cc.Prefab = null;
    //Punkt @property(cc.Vec2)
    vec2Var: cc.Vec2 = cc.v2();
    // Benutzerdefinierter Knoten @property(Player)
    SpielerVar:Player = null;
    // Hier kommt der Punkt, benutzerdefinierte Aufzählung/**
     * Globale Variablen* const LEVEL = cc.Enum({EASY:1,HARD:2});
     */ 
    @Eigentum({
        Typ: Ebene
    })
    enumVa = LEVEL.EINFACH;
}

importiere { Player } aus "./Player";

const { Eigenschaft, ccclass } = cc._decorator;

@ccklasse
Exportklasse Game erweitert cc.Component {
    // Diese Eigenschaft verweist auf die Prefab-Ressource des Sterns @property(cc.Prefab)
    privates StarPrefab: cc.Prefab = null;
    // Zufälliger Zeitraum, in dem Sterne nach ihrer Generierung verschwinden @property(cc.Integer)
    private maxStarDuration = 0;
    @Eigenschaft(cc.Integer)
    private minStarDuration = 0
    // Bodenknoten, der verwendet wird, um die Höhe der Sternerzeugung zu bestimmen @property(cc.Node)
    privater GroundNode: cc.Node = null;
    // Spielerknoten, der verwendet wird, um die Sprunghöhe des Protagonisten zu ermitteln und den Aktionsschalter des Protagonisten zu steuern @property(cc.Node)
    öffentlicher Spielerknoten: cc.Node = null;
    // Verweis auf Score-Label @property(cc.Label)
    privates ScoreLabel: cc.Label = null;
    // Ressource für die Vertonung von Soundeffekten @property(cc.AudioClip)
    privates ScoreAudio: cc.AudioClip = null;

    // Y-Achsenkoordinate des Bodenknotens private groundY: Zahl;
    //Timeröffentlicher Timer: Zahl;
    // Dauer der Existenz eines Sterns public starDuration: number;
    // Aktueller Spielstand private score: number;

    geschützt beim Laden() {
        // Holen Sie sich die Y-Achsenkoordinate der Bodenebene this.groundY = this.groundNode.y + this.groundNode.height / 2;
        // Timer initialisieren this.timer = 0;
        this.starDuration = 0;
        // Einen neuen Stern generieren this.spawnNewStar();
        // Wertung initialisieren this.score = 0;
    }

    // Einen neuen Stern generieren public spawnNewStar() {
        //Erstellen Sie mit der angegebenen Vorlage einen neuen Knoten in der Szene. let newStar = cc.instantiate(this.starPrefab);
        // Den neu hinzugefügten Knoten zum Canvas-Knoten hinzufügen this.node.addChild(newStar);
        // Eine zufällige Position für den Stern festlegen newStar.setPosition(this.getNewStarPosition());
        // Übergebe die Instanz der Spielkomponente an die Sternkomponente newStar.getComponent('Star').init(this);
        // Timer zurücksetzen this.starDuration = this.minStarDuration + cc.random0To1() * (this.maxStarDuration - this.minStarDuration);
        dieser.timer = 0;
    }

    // Die Position des neuen Sterns public getNewStarPosition() {
        sei randX = 0;
        // Holen Sie sich zufällig die Y-Koordinate eines Sterns basierend auf der Position der Bodenebene und der Sprunghöhe des Protagonisten. let randY = this.groundY + cc.random0To1() * this.playerNode.getComponent('Player').jumpHeight + 50;
        // Die x-Koordinate eines Sterns zufällig basierend auf der Bildschirmbreite abrufen let maxX = this.node.width / 2;
        randX = cc.randomMinus1To1() * maxX;
        //Gib die Sternkoordinaten zurück return cc.p(randX, randY);
    }

    // wird bei jedem Frame aufgerufen
    geschütztes Update(dt: Zahl) {
        // Aktualisiere den Timer bei jedem Frame. Wenn das Limit überschritten wird und keine neuen Sterne generiert werden, wird die Spielfehlerlogik aufgerufen, wenn (this.timer > this.starDuration) {
            dies.gameOver();
            zurückkehren;
        }
        dieser.timer += dt;
    }

    // Punktzahl public gainScore() {
        dieser.score += 1;
        // Text des ScoreDisplay-Labels aktualisieren this.scoreLabel.string = 'Score: ' + this.score.toString();
        // Den Soundeffekt der Partitur abspielen // Wenn Sie nicht as any hinzufügen, erhalten Sie eine Fehlermeldung. Wenn Sie es nicht glauben, versuchen Sie cc.audioEngine.play(this.scoreAudio as any, false, 1);
    }

    //gg
    privates gameOver() {
        this.playerNode.stopAllActions(); //Stoppt die Sprungaktion des Spielerknotens cc.director.loadScene('game');
    }

}

const { ccclass, Eigenschaft } = cc._decorator;

@ccklasse
Exportklasse Player erweitert cc.Component {
    // Die Sprunghöhe des Protagonisten @property(cc.Integer)
    private Sprunghöhe: Zahl = 0;
    // Die Dauer des Sprunges des Protagonisten @property(cc.Integer)
    private Sprungdauer: Zahl = 0;
    // Maximale Bewegungsgeschwindigkeit @property(cc.Integer)
    private maxMoveSpeed: Zahl = 0;
    // Beschleunigung@Eigenschaft(cc.Integer)
    private Beschleunigung: Zahl = 0;
    // Ressource für Sprung-Soundeffekte @property(cc.AudioClip)
    privates JumpAudio: cc.AudioClip = null;

    privates xSpeed: Zahl = 0;
    privater accLeft: boolean = false;
    privates accRight: boolean = false;
    private Sprungaktion: cc.Action = null;

    private setJumpAction() {
        // Nach oben springen let jumpUp = cc.moveBy(this.jumpDuration, cc.p(0, this.jumpHeight)).easing(cc.easeCubicActionOut());
        // Fallen lassen Sie jumpDown = cc.moveBy(this.jumpDuration, cc.p(0, -this.jumpHeight)).easing(cc.easeCubicActionIn());
        // Fügen Sie eine Rückruffunktion hinzu, um andere Methoden aufzurufen, die wir definiert haben, wenn die Aktion endet. let callback = cc.callFunc(this.playJumpSound, this);
        // Fortlaufend wiederholen und den Rückruf aufrufen, um den Ton jedes Mal abzuspielen, wenn die Landeaktion abgeschlossen ist. return cc.repeatForever(cc.sequence(jumpUp, jumpDown, callback));
    }

    private playJumpSound() {
        //Rufen Sie die Sound-Engine auf, um den Ton abzuspielen cc.audioEngine.play(this.jumpAudio as any, false, 1);
    }

    private addEventListeners() {
        cc.systemEvent.on(cc.SystemEvent.EventType.KEY_DOWN, dies.onKeyDown, dies);
        cc.systemEvent.on(cc.SystemEvent.EventType.KEY_UP, dies.onKeyUp, dies);
        cc.find("Canvas").on(cc.Node.EventType.TOUCH_START, dies.onScreenTouchStart, dies);
        cc.find("Canvas").on(cc.Node.EventType.TOUCH_CANCEL, dies.onScreenTouchEnd, dies);
        cc.find("Canvas").on(cc.Node.EventType.TOUCH_END, dies.onScreenTouchEnd, dies);
    }

    private moveLeft() {
        dies.accLeft = wahr;
        dies.accRight = falsch;
    }

    private moveRight() {
        dies.accLeft = falsch;
        dies.accRight = wahr;
    }

    private stopMove() {
        dies.accLeft = falsch;
        dies.accRight = falsch;
    }

    private onScreenTouchStart(Ereignis: cc.Event.EventTouch) {
        wenn (event.getLocationX() > cc.winSize.width/2) {
            dies.nachRechts verschieben();
        } anders {
            dies.moveLeft();
        }
    }

    private onScreenTouchEnd() {
        dies.stopMove();
    }

    private onKeyDown(Ereignis: cc.Event.EventKeyboard) {
        Schalter ((Ereignis als beliebig).Schlüsselcode) {
            Fall cc.KEY.a:
            Fall cc.KEY.links:
                dies.moveLeft();
                brechen;
            Fall cc.KEY.d:
            Fall cc.KEY.rechts:
                dies.nachRechts verschieben();
                brechen;
        }
    }

    private onKeyUp(Ereignis: cc.Event.EventKeyboard) {
        Schalter ((Ereignis als beliebig).Schlüsselcode) {
            Fall cc.KEY.a:
            Fall cc.KEY.links:
                dies.stopMove();
                brechen;
            Fall cc.KEY.d:
            Fall cc.KEY.rechts:
                dies.stopMove();
                brechen;
        }
    }

    //verwende dies zur Initialisierung
    geschützt beim Laden() {
        // Initialisieren Sie die Sprungaktion this.jumpAction = this.setJumpAction();
        dies.node.runAction(diese.jumpAction);

        // Beschleunigungsrichtungsschalter this.accLeft = false;
        dies.accRight = falsch;
        // Die aktuelle horizontale Geschwindigkeit des Protagonisten this.xSpeed ​​​​= 0;

        // Initialisiere die abhörende Eingabe this.addEventListeners();
    }

    // wird bei jedem Frame aufgerufen
    geschütztes Update(dt: Zahl) {
        // Aktualisiere die Geschwindigkeit bei jedem Frame entsprechend der aktuellen Beschleunigungsrichtung if (this.accLeft) {
            dies.xSpeed ​​​​-= dies.accel * dt;
        } sonst wenn (dies.accRight) {
            dies.xSpeed ​​​​+= dies.accel * dt;
        }
        // Begrenzen Sie die Geschwindigkeit des Protagonisten, sodass sie den Maximalwert nicht überschreitet, wenn (Math.abs(this.xSpeed) > this.maxMoveSpeed) {
            // wenn die Geschwindigkeit den Grenzwert erreicht, verwende die Höchstgeschwindigkeit in der aktuellen Richtung
            dies.xSpeed ​​​​= dies.maxMoveSpeed ​​​​* dies.xSpeed ​​​​/ Math.abs(diese.xSpeed);
        }

        // Aktualisiere die Position des Protagonisten entsprechend der aktuellen Geschwindigkeit this.node.x += this.xSpeed ​​​​* dt;
        wenn (this.node.x <= -this.node.parent.width / 2) {
            dieser.Knoten.x = dieser.Knoten.übergeordnet.Breite / 2;
        }
        wenn (dieser.Knoten.x > dieser.Knoten.übergeordnete.Breite / 2) {
            dieser.Knoten.x = -this.node.parent.width / 2;
        }
    }

}

importiere { Spiel } aus "./Game";

const {ccclass,property} = cc._decorator;

@ccklasse
Exportklasse Star erweitert cc.Component {

    // Wenn der Abstand zwischen dem Star und dem Protagonisten diesen Wert erreicht, wird die Sammlung vervollständigt @property(cc.Integer)
    privater PickRadius: Zahl = 0;
    privates Spiel:Spiel = null;

    öffentliche init(Spiel:Spiel) {
        dieses.spiel = Spiel;
    }

    getPlayerDistance() {
        // Bestimme die Distanz basierend auf der Position des Spielerknotens let playerPos = this.game.playerNode.getPosition();
        // Berechnen Sie die Entfernung zwischen zwei Punkten basierend auf ihren Positionen. let dist = cc.pDistance(this.node.position, playerPos);
        Rückwegverteiler;
    }

    beiAusgewählt() {
        // Wenn ein Stern gesammelt wurde, rufen Sie die Schnittstelle im Spielskript auf, um einen neuen Stern zu generieren this.game.spawnNewStar();
        //Rufen Sie die Bewertungsmethode des Spielskripts auf: this.game.gainScore();
        // Dann zerstöre den aktuellen Sternknoten this.node.destroy();
    }

    // wird bei jedem Frame aufgerufen
    update(dt:Nummer) {
        // In jedem Frame wird bestimmt, ob die Distanz zwischen Spieler und Hauptfigur kleiner ist als die Sammlungsdistanz if (this.getPlayerDistance() < this.pickRadius) {
            //Rufen Sie das Sammlungsverhalten this.onPicked(); auf.
            zurückkehren;
        }
        // Aktualisiere die Transparenz des Sterns entsprechend dem Timer im Spielskript. let opacityRatio = 1 – this.game.timer/this.game.starDuration;
        sei minOpacity = 50;
        this.node.opacity = minOpacity + Math.floor(opacityRatio * (255 - minOpacity));
    }

}