561 lines
20 KiB
TypeScript
561 lines
20 KiB
TypeScript
import StateMachineAI from "../../Wolfie2D/AI/StateMachineAI";
|
|
import GameNode, { TweenableProperties } from "../../Wolfie2D/Nodes/GameNode";
|
|
import Vec2 from "../../Wolfie2D/DataTypes/Vec2";
|
|
import Sprite from "../../Wolfie2D/Nodes/Sprites/Sprite";
|
|
import OrthogonalTilemap from "../../Wolfie2D/Nodes/Tilemaps/OrthogonalTilemap";
|
|
import { Player_Events } from "../sword_enums";
|
|
import Fall from "./PlayerStates/Fall";
|
|
import Idle from "./PlayerStates/Idle";
|
|
import InAir from "./PlayerStates/InAir";
|
|
import Jump from "./PlayerStates/Jump";
|
|
import Walk from "./PlayerStates/Walk";
|
|
import Debug from "../../Wolfie2D/Debug/Debug";
|
|
import Item from "../GameSystems/items/Item";
|
|
import InventoryManager from "../GameSystems/InventoryManager";
|
|
import BattlerAI from "../AI/BattlerAI";
|
|
import MathUtils from "../../Wolfie2D/Utils/MathUtils";
|
|
import Weapon from "../GameSystems/items/Weapon";
|
|
import AnimatedSprite from "../../Wolfie2D/Nodes/Sprites/AnimatedSprite";
|
|
import InputWrapper from "../Tools/InputWrapper";
|
|
import EnemyAI from "../AI/EnemyAI";
|
|
import Timer from "../../Wolfie2D/Timing/Timer";
|
|
import PlayerState from "./PlayerStates/PlayerState";
|
|
import { GameEventType } from "../../Wolfie2D/Events/GameEventType";
|
|
|
|
export enum PlayerType {
|
|
PLATFORMER = "platformer",
|
|
TOPDOWN = "topdown"
|
|
}
|
|
|
|
export enum PlayerStates {
|
|
IDLE = "idle",
|
|
WALK = "walk",
|
|
JUMP = "jump",
|
|
FALL = "fall",
|
|
PREVIOUS = "previous"
|
|
}
|
|
|
|
export enum BuffType {
|
|
ATK = "attack",
|
|
DEF = "defence",
|
|
HEALTH = "health",
|
|
SPEED = "speed",
|
|
RANGE = "range",
|
|
ATKSPEED = "attackspeed",
|
|
DOUBLESTRIKE = "doublestrike",
|
|
POISON = "poison",
|
|
BLEED = "bleed",
|
|
BURN = "burn",
|
|
EXTRA_DOT = "extradot",
|
|
SHIELD = "shield",
|
|
SHIELD_DMG = "shielddmg", //increase shield dmg ratio
|
|
LIFESTEAL = "lifesteal",
|
|
LIFESTEALBUFF = "lifestealbuff",
|
|
EXTRALIFE= "extralife",
|
|
ONESHOT = "oneshot",
|
|
JUMP = "jump"
|
|
}
|
|
|
|
|
|
export class Buff {
|
|
"type": BuffType;
|
|
"value": number;
|
|
//"bonus": boolean, //need to determine what bonus gives
|
|
"string"? : string;
|
|
"category" : BuffCategory
|
|
}
|
|
|
|
|
|
|
|
//TODO - need better names
|
|
export enum BuffCategory{
|
|
ATTACK = "ATTACK",
|
|
DOT = "DOT",
|
|
SHIELD = "SHIELD",
|
|
HEALTH = "HEALTH",
|
|
EXTRA = "EXTRA"
|
|
}
|
|
|
|
//TODO - discuss max stats during refinement, unused for now
|
|
export default class PlayerController extends StateMachineAI implements BattlerAI{
|
|
owner: GameNode;
|
|
velocity: Vec2 = Vec2.ZERO;
|
|
//will need to discuss redundant stats
|
|
speed: number = 200;
|
|
MIN_SPEED: number = 200;
|
|
MAX_SPEED: number = 300;
|
|
BASE_HP: number = 100;
|
|
MAX_HP: number = 100;
|
|
CURRENT_HP: number = 100;
|
|
BASE_ATK: number = 100;
|
|
CURRENT_ATK: number = 100;
|
|
damage_multiplier: number = 1;
|
|
CURRENT_EXP : number = 0;
|
|
MAX_EXP : number = 100;
|
|
CURRENT_SHIELD : number =0;
|
|
MAX_SHIELD : number = 20;
|
|
invincible : boolean = false;
|
|
level : number = 1;
|
|
|
|
godMode: boolean = false;
|
|
|
|
tilemap: OrthogonalTilemap;
|
|
|
|
//for doublejumps maybe = # of jumps in air allowed
|
|
MAX_airjumps: number = 1;
|
|
airjumps:number = 0;
|
|
|
|
private lookDirection: Vec2;
|
|
/** A list of items in the game world */
|
|
private items: Array<Item>;
|
|
|
|
// The inventory of the player
|
|
inventory: InventoryManager;
|
|
|
|
static invincibilityTimer: Timer;
|
|
|
|
static buffPool : Array<BuffCategory> = new Array();
|
|
|
|
static appliedBuffs: Array<Buff> = new Array();
|
|
|
|
//add to current_buffs later
|
|
hasBleed : Boolean = false;
|
|
hasPoison : Boolean = false;
|
|
hasBurn : Boolean = false;
|
|
hasShield : Boolean = false;
|
|
shieldDamage : number = 1;
|
|
hasDoubleStrike : Boolean = false;
|
|
hasLifesteal : Boolean = false;
|
|
lifestealratio : number = 0; //percent of damage to steal
|
|
hasOneShot: Boolean = false;
|
|
extraDotDmg : number =0;
|
|
lives: number = 1;
|
|
cooldownMultiplier : number = 1;
|
|
|
|
//TODO - add new buffs here
|
|
CURRENT_BUFFS: {
|
|
atk: number; //flat value to add to weapon
|
|
hp: number; //flat value
|
|
def: number; //flat value
|
|
speed: number; //flat value
|
|
range:number; //range will be a multiplier value: 1.5 = 150% range
|
|
}
|
|
|
|
|
|
|
|
//TODO - get the correct tilemap
|
|
initializeAI(owner: GameNode, options: Record<string, any>){
|
|
this.owner = owner;
|
|
|
|
this.initializePlatformer();
|
|
|
|
this.tilemap = this.owner.getScene().getTilemap(options.tilemap) as OrthogonalTilemap;
|
|
|
|
this.inventory = options.inventory;
|
|
|
|
this.lookDirection = new Vec2();
|
|
|
|
this.CURRENT_BUFFS = {hp:0, atk:0, def:0, speed:0, range:0};
|
|
|
|
|
|
//i frame timer
|
|
PlayerController.invincibilityTimer = new Timer(2000);
|
|
|
|
//initialize the buff pool - each has same weight at first
|
|
PlayerController.buffPool = new Array();
|
|
for( let i=0 ; i< 4; i++){
|
|
PlayerController.buffPool.push(BuffCategory.ATTACK);
|
|
PlayerController.buffPool.push(BuffCategory.EXTRA);
|
|
PlayerController.buffPool.push(BuffCategory.DOT);
|
|
PlayerController.buffPool.push(BuffCategory.SHIELD);
|
|
PlayerController.buffPool.push(BuffCategory.HEALTH);
|
|
}
|
|
|
|
//to test the buffs
|
|
//this.addBuff( {type:BuffType.HEALTH, value:1} );
|
|
//this.addBuff({type:BuffType.BURN, value:1, category:BuffCategory.DOT});
|
|
//this.addBuff({type:BuffType.BLEED, value:1, category:BuffCategory.DOT});
|
|
//this.addBuff({type:BuffType.POISON, value:1, category:BuffCategory.DOT});
|
|
|
|
|
|
}
|
|
|
|
initializePlatformer(): void {
|
|
this.speed = 400;
|
|
|
|
let idle = new Idle(this, this.owner);
|
|
this.addState(PlayerStates.IDLE, idle);
|
|
let walk = new Walk(this, this.owner);
|
|
this.addState(PlayerStates.WALK, walk);
|
|
let jump = new Jump(this, this.owner);
|
|
this.addState(PlayerStates.JUMP, jump);
|
|
let fall = new Fall(this, this.owner);
|
|
this.addState(PlayerStates.FALL, fall);
|
|
|
|
this.initialize(PlayerStates.IDLE);
|
|
}
|
|
|
|
changeState(stateName: string): void {
|
|
// If we jump or fall, push the state so we can go back to our current state later
|
|
// unless we're going from jump to fall or something
|
|
if((stateName === PlayerStates.JUMP || stateName === PlayerStates.FALL) && !(this.stack.peek() instanceof InAir)){
|
|
this.stack.push(this.stateMap.get(stateName));
|
|
}
|
|
|
|
super.changeState(stateName);
|
|
}
|
|
|
|
update(deltaT: number): void {
|
|
super.update(deltaT);
|
|
if(PlayerController.invincibilityTimer.isStopped()){
|
|
this.invincible = false;
|
|
}
|
|
|
|
if(this.currentState instanceof Jump){
|
|
Debug.log("playerstate", "Player State: Jump");
|
|
} else if (this.currentState instanceof Walk){
|
|
Debug.log("playerstate", "Player State: Walk");
|
|
} else if (this.currentState instanceof Idle){
|
|
Debug.log("playerstate", "Player State: Idle");
|
|
} else if(this.currentState instanceof Fall){
|
|
Debug.log("playerstate", "Player State: Fall");
|
|
}
|
|
Debug.log("player speed", "player speed: x: " + this.velocity.x + ", y:" + this.velocity.y);
|
|
Debug.log("player Coords:", "Player Coords:" +this.owner.position );
|
|
|
|
//testing the attacks here, may be moved to another place later
|
|
if(InputWrapper.isAttackJustPressed()){
|
|
let item = this.inventory.getItem();
|
|
(<AnimatedSprite>this.owner).animation.play("ATTACK", true);
|
|
//TODO - get proper look direction
|
|
this.lookDirection.x = (<Sprite>this.owner).invertX ? -1 : 1;
|
|
// If there is an item in the current slot, use it
|
|
if (item) {
|
|
item.use(this.owner, "player", this.lookDirection);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// TODO - figure out attacker
|
|
damage(damage: number, attacker?: GameNode): void {
|
|
if (this.godMode) {
|
|
//console.log("godmode");
|
|
return;
|
|
}
|
|
if( !this.invincible && PlayerState.dashTimer.isStopped()){
|
|
//console.log("take damage");
|
|
//i frame here
|
|
PlayerController.invincibilityTimer.start();
|
|
this.invincible = true;
|
|
//shield absorbs the damage and sends dmg back to attacker
|
|
if(this.CURRENT_SHIELD > 0){
|
|
let newshield = Math.max(0, this.CURRENT_SHIELD - damage ); //calculate the new shield value
|
|
if( attacker !== undefined){
|
|
(<EnemyAI>attacker._ai).damage((this.CURRENT_SHIELD - newshield) * this.shieldDamage); //damage the attacker the dmg taken to shield
|
|
}
|
|
this.CURRENT_SHIELD = newshield; //update shield value
|
|
}
|
|
else{
|
|
//i frame here
|
|
PlayerController.invincibilityTimer.start();
|
|
this.invincible = true;
|
|
//console.log("hurt anim");
|
|
(<AnimatedSprite>this.owner).animation.play("HURT" );
|
|
damage *= this.damage_multiplier;
|
|
damage = parseFloat(damage.toPrecision(2));
|
|
this.CURRENT_HP -= damage;
|
|
this.emitter.fireEvent(GameEventType.PLAY_SOUND, {key: "hurt", loop: false, holdReference: false});
|
|
|
|
//if player has shield buff give them shield when damaged
|
|
if(this.hasShield){
|
|
this.CURRENT_SHIELD += damage * .5;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
else{
|
|
//console.log("player is invincible");
|
|
}
|
|
|
|
if(this.CURRENT_HP <= 0){
|
|
this.lives --;
|
|
(<AnimatedSprite>this.owner).animation.play("DYING");
|
|
(<AnimatedSprite>this.owner).animation.queue("DEAD", true, Player_Events.PLAYER_KILLED);
|
|
this.emitter.fireEvent(Player_Events.PLAYER_KILLED);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gives the player a certain amount of shield
|
|
* @param shield amount of shield to add to player
|
|
*/
|
|
addShield(shield : number){
|
|
this.CURRENT_SHIELD = (this.CURRENT_SHIELD + shield) % this.MAX_SHIELD;
|
|
}
|
|
|
|
/**
|
|
* gives health to the player
|
|
* @param health health to give player
|
|
*/
|
|
addHealth(health : number){
|
|
this.CURRENT_HP += health;
|
|
if(this.CURRENT_HP > this.MAX_HP + this.CURRENT_BUFFS.hp){
|
|
this.CURRENT_HP = this.MAX_HP + this.CURRENT_BUFFS.hp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gives the player exp
|
|
* @param exp amount of exp to give the player
|
|
*/
|
|
giveExp(exp: number){
|
|
this.CURRENT_EXP += exp;
|
|
//if > than max exp level up (give buff)
|
|
if(this.CURRENT_EXP >= this.MAX_EXP){
|
|
this.CURRENT_EXP -= this.MAX_EXP;
|
|
this.MAX_EXP += 50; //increase max exp needed for level up
|
|
this.level++ ;
|
|
this.emitter.fireEvent(GameEventType.PLAY_SOUND, {key: "level_up", loop: false, holdReference: false});
|
|
this.emitter.fireEvent(Player_Events.GIVE_BUFF);
|
|
}
|
|
}
|
|
//TODO - balance buff value generation
|
|
/**
|
|
* returns an array of three randomly generated buffs
|
|
* @param val optional value to give buff
|
|
* @returns array of three Buffs
|
|
*/
|
|
generateBuffs( val? : number) : Buff[]{
|
|
//shuffle pool of buff categories
|
|
PlayerController.buffPool.sort(() => 0.5 - Math.random());
|
|
|
|
// Get sub-array of first 3 elements after shuffled
|
|
let shuffled = PlayerController.buffPool.slice(0, 3); //3 buff categories
|
|
|
|
let num = parseFloat(Math.random().toPrecision(1)) * 10; //random number from 1 to 10 if no value given
|
|
if(typeof val !== 'undefined'){
|
|
num = val;
|
|
}
|
|
|
|
//TODO - implement better buff genertion - some buffs dont want multiple of
|
|
let attackBuffs : Buff[] = [
|
|
{type:BuffType.RANGE, value:num/10, category: BuffCategory.ATTACK},
|
|
{type:BuffType.ATKSPEED, value:num, category: BuffCategory.ATTACK},
|
|
];
|
|
if(!this.hasDoubleStrike){
|
|
attackBuffs.push({type:BuffType.DOUBLESTRIKE, value:num, category: BuffCategory.ATTACK, string:"your attacks are \nfollowed by a \nweaker strike"});
|
|
}
|
|
|
|
let dotBuffs : Buff[] = [
|
|
];
|
|
if(!this.hasBleed){
|
|
dotBuffs.push({type:BuffType.BLEED, value:1, category: BuffCategory.DOT, string: "Your hits \napply Bleed"});
|
|
}
|
|
if(!this.hasBurn){
|
|
dotBuffs.push({type:BuffType.BURN, value:1, category: BuffCategory.DOT, string: "Your hits \napply Burn"});
|
|
}
|
|
if(!this.hasPoison){
|
|
dotBuffs.push({type:BuffType.POISON, value:1, category: BuffCategory.DOT, string: "Your hits \napply poison"});
|
|
}
|
|
|
|
//only add extra dot if at least one dot is acquired
|
|
for(let i=dotBuffs.length; i< 3 ; i++){
|
|
dotBuffs.push({type:BuffType.EXTRA_DOT, value:num, category: BuffCategory.DOT, string: "increase your \nDOT damage"});
|
|
}
|
|
|
|
|
|
let shieldBuffs : Buff[] = [
|
|
{type:BuffType.HEALTH, value:num, category: BuffCategory.SHIELD},
|
|
];
|
|
//if player doesnt have shield buff, give them the option, otherwise give buff shield option
|
|
if(!this.hasShield){
|
|
shieldBuffs.push({type:BuffType.SHIELD, value:1, category: BuffCategory.SHIELD, string: "Gain Shield \nWhen Damaged \n Shields return \nthe damage taken \nto attacker"});
|
|
}
|
|
else{
|
|
shieldBuffs.push({type:BuffType.SHIELD_DMG, value:num, category: BuffCategory.SHIELD, string: "increase damage \nreturned by shield"});
|
|
}
|
|
|
|
|
|
let healthBuffs : Buff[] = [
|
|
{type:BuffType.DEF, value: num/10, category: BuffCategory.HEALTH, string: "decrease damage by"+num/10+"%"}
|
|
];
|
|
if(!this.hasLifesteal){
|
|
healthBuffs.push({type:BuffType.LIFESTEAL, value:1, category: BuffCategory.HEALTH, string:"Gain lifesteal"});
|
|
}
|
|
else{
|
|
healthBuffs.push({type:BuffType.LIFESTEALBUFF, value:num/10, category: BuffCategory.HEALTH, string:"Increase Lifesteal \nstrength by "+ num+ "%"});
|
|
}
|
|
|
|
|
|
let extraBuffs : Buff[] = [
|
|
{type:BuffType.EXTRALIFE, value:1, category: BuffCategory.EXTRA, string: "Gain an \nExtra Life"},
|
|
{type:BuffType.SPEED, value:num, category: BuffCategory.EXTRA},
|
|
{type:BuffType.ATK, value:num, category: BuffCategory.EXTRA}
|
|
];
|
|
if(!this.hasOneShot){ //only add oneshot buff if it isnt already included
|
|
extraBuffs.push({type:BuffType.ONESHOT, value:1, category: BuffCategory.EXTRA, string: "Your hits hurt \n100x more but \nyour max health \nis set to 1 "});
|
|
};
|
|
|
|
|
|
let selected = new Array();
|
|
while( shuffled.length != 0){
|
|
let cat = shuffled.pop();
|
|
switch(cat){
|
|
case BuffCategory.ATTACK:
|
|
attackBuffs.sort(() => 0.5 - Math.random());
|
|
if(attackBuffs.length == 0){
|
|
selected.push({type:BuffType.RANGE, value:num/10, category: BuffCategory.ATTACK});
|
|
}
|
|
else{
|
|
selected.push(attackBuffs.pop());
|
|
}
|
|
break;
|
|
case BuffCategory.DOT:
|
|
dotBuffs.sort(() => 0.5 - Math.random());
|
|
if(dotBuffs.length == 0){
|
|
selected.push({type:BuffType.EXTRA_DOT, value:num, category: BuffCategory.DOT, string: "increase your \nDOT damage"});
|
|
}
|
|
else{
|
|
selected.push(dotBuffs.pop());
|
|
}
|
|
break;
|
|
case BuffCategory.EXTRA:
|
|
extraBuffs.sort(() => 0.5 - Math.random());
|
|
if(extraBuffs.length ==0 ){
|
|
selected.push({type:BuffType.EXTRALIFE, value:1, category: BuffCategory.EXTRA, string: "Gain an \nExtra Life"});
|
|
}
|
|
else{
|
|
selected.push(extraBuffs.pop());
|
|
}
|
|
break;
|
|
case BuffCategory.HEALTH:
|
|
healthBuffs.sort(() => 0.5 - Math.random());
|
|
if(healthBuffs.length == 0){
|
|
selected.push({type:BuffType.DEF, value: num/10, category: BuffCategory.HEALTH, string: "decrease damage\n taken by "+num*10+"%"});
|
|
}
|
|
else{
|
|
selected.push(healthBuffs.pop());
|
|
}
|
|
break;
|
|
case BuffCategory.SHIELD:
|
|
shieldBuffs.sort(() => 0.5 - Math.random());
|
|
if(shieldBuffs.length ==0 ){
|
|
selected.push({type:BuffType.HEALTH, value:num, category: BuffCategory.SHIELD});
|
|
}
|
|
else{
|
|
selected.push(shieldBuffs.pop());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return selected;
|
|
}
|
|
|
|
/**
|
|
* Add given buff to the player
|
|
* @param buff Given buff
|
|
*/
|
|
addBuff(buff: Buff): void {
|
|
|
|
//increase weight of selected buff category
|
|
PlayerController.buffPool.push(buff.category);
|
|
//add buff to array of applied buffs
|
|
PlayerController.appliedBuffs.push(buff);
|
|
// TODO
|
|
let item = this.inventory.getItem();
|
|
switch(buff.type){
|
|
case BuffType.HEALTH:
|
|
this.CURRENT_BUFFS.hp += buff.value;
|
|
this.CURRENT_HP += buff.value;
|
|
break;
|
|
case BuffType.ATK:
|
|
//TODO - decide what to do with atk stat
|
|
this.CURRENT_BUFFS.atk += buff.value;
|
|
this.CURRENT_ATK +=buff.value;
|
|
break;
|
|
case BuffType.SPEED:
|
|
this.CURRENT_BUFFS.speed += buff.value;
|
|
this.speed += buff.value;
|
|
break;
|
|
case BuffType.DEF:
|
|
this.damage_multiplier *= (1-buff.value);
|
|
break;
|
|
case BuffType.RANGE:
|
|
this.CURRENT_BUFFS.range += buff.value;
|
|
if (item) {
|
|
(<Weapon>item).EXTRA_RANGE += buff.value;
|
|
}
|
|
break;
|
|
|
|
//TODO
|
|
case BuffType.BLEED:
|
|
this.hasBleed = true;
|
|
break;
|
|
case BuffType.BURN:
|
|
this.hasBurn = true;
|
|
break;
|
|
case BuffType.POISON:
|
|
this.hasPoison = true;
|
|
break;
|
|
case BuffType.EXTRA_DOT:
|
|
this.extraDotDmg += buff.value;
|
|
break;
|
|
case BuffType.SHIELD:
|
|
this.hasShield = true;
|
|
break;
|
|
|
|
case BuffType.ATKSPEED:
|
|
if (item) {
|
|
this.cooldownMultiplier -= buff.value;
|
|
//reduce cooldowntimer
|
|
(<Weapon>item).cooldownTimer = new Timer((<Weapon>item).cooldown * this.cooldownMultiplier )
|
|
}
|
|
break;
|
|
case BuffType.DOUBLESTRIKE:
|
|
//TODO -
|
|
break;
|
|
case BuffType.SHIELD_DMG:
|
|
this.shieldDamage += buff.value/10 ;
|
|
break;
|
|
case BuffType.EXTRALIFE:
|
|
this.lives ++;
|
|
break;
|
|
case BuffType.LIFESTEAL:
|
|
this.hasLifesteal = true;
|
|
this.lifestealratio = .2; //20% lifesteal
|
|
break;
|
|
case BuffType.LIFESTEALBUFF:
|
|
this.lifestealratio += buff.value;
|
|
break;
|
|
case BuffType.ONESHOT:
|
|
this.MAX_HP = 1;
|
|
this.CURRENT_HP = 1;
|
|
this.CURRENT_ATK *= 100;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @returns record of the player stats
|
|
*/
|
|
getStats(): Record<string, any>{
|
|
let stats = {} as Record<string,any>;
|
|
stats.CURRENT_HP = this.CURRENT_HP;
|
|
stats.CURRENT_ATK = this.CURRENT_ATK;
|
|
stats.CURRENT_SHIELD = this.CURRENT_SHIELD;
|
|
stats.CURRENT_EXP = this.CURRENT_EXP;
|
|
|
|
return
|
|
}
|
|
|
|
|
|
toString(): string{
|
|
return "";
|
|
}
|
|
|
|
} |