katboi01
/
KF-MMO-Server
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Inventory system improvements, 

stats
This commit is contained in:
Katboi01 2023-09-18 12:33:06 +02:00
parent 870aa12161
commit 0beec15332
14 changed files with 203 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,2 @@
{
}

5
Account/accountSocket.ts
View File

@ -5,7 +5,7 @@ import { users } from "./users";
import { players } from "../Player/players";
export function registerAccountCallbacks(socket){
function emitLogin(user : userData, player:playerData, registered:boolean = false){
function emitLogin(user : userData | null, player:playerData, registered:boolean = false){
if(user != null){
socket.emit("account/login", JSON.stringify(new loginResponse(true, user, player)));
socket.user = user
@ -46,6 +46,9 @@ export function registerAccountCallbacks(socket){
let player = null
if(result != null){
player = players.readPlayer(result.id)
if(player == null){
player = players.createPlayer(result.id)
}
}
emitLogin(result, player);

60
Classes/itemData.ts
View File

@ -1,9 +1,57 @@
import { enums } from "./enums"
import { game } from "../game"
export class itemData{
name : string
id : number
rarity: number
itemType : number
stats = {}
name : string
id : number
templateId : number
rarity : number
count : number = 1
stats : Stat[] = []
static fromPersistentData(data : persistentItemData){
let item = new itemData()
item.name = data.name;
item.id = ++game.itemCount;
item.templateId = data.id;
item.rarity = Math.floor(Math.random()*data.rarityMax);
item.count = 1;
return item
}
static copy(data : itemData){
let item = new itemData()
item.name = data.name;
item.id = data.id;
item.templateId = data.templateId;
item.rarity = data.rarity
item.count = data.count
data.stats.forEach(stat=>item.stats.push(stat))
return item
}
}
export class persistentItemData{
name: string
id: number
itemType: number
description: string
rarityMin: number
rarityMax: number
maxCount: number
tags: number[] = []
stats: Stat[] = []
constructor(init?: Partial<persistentItemData>) {
Object.assign(this, init);
}
}
export interface Stat {
Key: number
Value: number
}

2
Classes/itemGenerated.ts
View File

@ -2,5 +2,5 @@ import { itemData } from "./itemData"
export class itemGenerated{
instanceId: number
item: itemData
item: itemData | null
}

2
Classes/lobbyState.ts
View File

@ -13,7 +13,7 @@ export class lobbyState{
lobby.players = []
lobby.users = []
for (let i = 0; i < this.players.length; i++) {
lobby.players.push(playerData.copyLight(this.players[i]));
lobby.players.push(this.players[i].copyLight());
}
return lobby
}

34
Classes/playerData.ts
View File

@ -3,14 +3,42 @@ import { playerInventory } from "./playerInventory";
export class playerData{
id : number
level : number = 1
characterId : number
inventory : playerInventory = new playerInventory()
rigidbody : physicsObject = new physicsObject()
static copyLight(data : playerData){
copyLight(){
let player : any = {}
player.id = data.id
player.rigidbody = data.rigidbody
player.id = this.id
player.rigidbody = this.rigidbody
return player
}
getItemById(id : number){
let item = this.inventory.items.find(i=>i.id == id)
return item
}
validateEquipment(){
if(this.inventory.weapon != -1){
if(this.getItemById(this.inventory.weapon) == null){
this.inventory.weapon == -1;
}
}
if(this.inventory.equipment[0] != -1){
if(this.getItemById(this.inventory.equipment[0]) == null){
this.inventory.equipment[0] == -1;
}
}
if(this.inventory.equipment[1] != -1){
if(this.getItemById(this.inventory.equipment[1]) == null){
this.inventory.equipment[1] == -1;
}
}
}
constructor(init?: Partial<playerData>) {
Object.assign(this, init);
}
}

12
Classes/playerInventory.ts
View File

@ -4,16 +4,4 @@ export class playerInventory{
weapon : number = -1
equipment : number[] = [-1,-1]
items : itemData[] = []
static validate(inv : playerInventory){
if(inv.equipment[0] == inv.weapon){
inv.equipment[0] = -1
}
if(inv.equipment[1] == inv.weapon){
inv.equipment[1] = -1
}
if(inv.equipment[1] == inv.equipment[0]){
inv.equipment[1] = -1
}
}
}

52
Items/itemGeneration.ts
View File

@ -1,38 +1,20 @@
import { enums } from "../Classes/enums";
import { itemData } from "../Classes/itemData";
import { itemData, persistentItemData } from "../Classes/itemData";
import {game} from "../game";
let consumableNames = ["soda", "bread"]
let currencyNames = ["stick", "rock", "leaf", "coin"]
let equipmentNames = ["umbrella", "sock", "bag"]
let miscNames = ["book", "envelope"]
export function generateItem(itemType : number){
let item = new itemData()
item.id = ++game.itemCount;
item.itemType = itemType
item.rarity = Math.floor(Math.random()*100)
switch(itemType){
case enums.itemType.undefined:{
item.name = miscNames[Math.floor(Math.random()*miscNames.length)];
break
}
case enums.itemType.consumable:{
item.name = consumableNames[Math.floor(Math.random()*consumableNames.length)];
break
}
case enums.itemType.currency:{
item.name = currencyNames[Math.floor(Math.random()*currencyNames.length)];
break
}
case enums.itemType.equipment:{
item.name = equipmentNames[Math.floor(Math.random()*equipmentNames.length)];
break
}
}
return item
function getRandom(arr){
return arr[Math.floor(Math.random()*arr.length)]
}
export function generateItemByType(itemType : number){
let items = game.itemsDB.filter(i=>i.itemType == itemType)
if(items.length == 0){
console.log("Error, can't generate item type " + itemType)
return null
}
else{
let itemTemplate : persistentItemData = getRandom(items)
let item = itemData.fromPersistentData(itemTemplate)
return item
}
}

68
Items/itemSocket.ts
View File

@ -1,9 +1,8 @@
import { itemData } from "../Classes/itemData";
import { itemGenerated } from "../Classes/itemGenerated";
import { generateItem } from "./itemGeneration";
import { generateItemByType } from "./itemGeneration";
import { itemRequest } from "../Classes/itemRequest";
import { lobbyMessage } from "../Classes/lobbyMessage";
import { userData } from "../Classes/userData";
import { game } from "../game";
import { playerData } from "../Classes/playerData";
@ -16,21 +15,60 @@ export function registerItemCallbacks(socket){
let player : playerData = socket.player
if(player != null){
let message = socket.user.login + " picked up "
if(data1.rarity >= 95){
message += "<color=purple>" + data1.name + "</color> (epic)"
let inventory = player.inventory
let template = game.getItemTemplate(data1.templateId)
let items = inventory.items.filter(i=>i.templateId == data1.templateId)
let totalAdded = 0
if(data1.count > template.maxCount)
{
console.log("ERROR ERROR ITEM ERROR")
return;
}
else if(data1.rarity >= 75){
message += "<color=red>" + data1.name + "</color> (rare)"
items.forEach(item=>{
var maxAmount = Math.min(template.maxCount - item.count, data1.count - totalAdded);
if (maxAmount > 0)
{
item.count += maxAmount;
totalAdded += maxAmount;
}
})
if(totalAdded < data1.count)
{
let maxAmount = data1.count - totalAdded
let itemCopy = itemData.copy(data1);
itemCopy.count = maxAmount;
totalAdded += maxAmount;
inventory.items.push(itemCopy);
}
else if(data1.rarity >= 60){
message += "<color=yellow>" + data1.name + "</color> (uncommon)"
if (totalAdded == data1.count)
{
if(data1.rarity >= 75){
let message = socket.user.login + " picked up "
if(data1.rarity >= 95){
message += "<color=purple>" + data1.name + "</color> (epic)"
}
else if(data1.rarity >= 75){
message += "<color=red>" + data1.name + "</color> (rare)"
}
else if(data1.rarity >= 60){
message += "<color=yellow>" + data1.name + "</color> (uncommon)"
}
else
message += data1.name;
game.addMessage(new lobbyMessage(message))
}
}
else
message += data1.name;
player.inventory.items.push(data1)
game.addMessage(new lobbyMessage(message))
{
console.log("ERROR ERROR ITEM ERROR")
}
}
});
@ -40,7 +78,7 @@ export function registerItemCallbacks(socket){
let buff = Buffer.from(data, 'base64');
let data1 = Number(buff.toString('utf-8'));
let player : playerData = socket.user.playerData
let player : playerData = socket.player
let item = player.inventory.items.findIndex(i=>i.id == data1);
if(item == -1){
console.log("Error! Item " + item + " not found!")
@ -56,7 +94,7 @@ export function registerItemCallbacks(socket){
let response = new itemGenerated()
response.instanceId = data1.instanceId
response.item = generateItem(data1.itemType)
response.item = generateItemByType(data1.itemType)
socket.emit("item/generated", JSON.stringify(response))
});

20
Items/items.ts Normal file
View File

@ -0,0 +1,20 @@
import { persistentItemData } from "../Classes/itemData";
import { game } from "../game";
const fs = require('fs');
export function loadItems(){
fs.mkdirSync(`Database/Items/`, { recursive: true })
fs.readdir(`Database/Items/`, (err, files) => {
files.forEach(file => {
fs.readFile(`Database/Items/${file}`, (err, data) => {
if (err) throw err;
let data1 = JSON.parse(data);
data1.forEach(item => {
let item1 = new persistentItemData(item)
game.itemsDB.push(item1)
});
});
});
});
}

7
Lobby/lobbySocket.ts
View File

@ -46,9 +46,10 @@ export function registerLobbyCallbacks(socket){
let buff = Buffer.from(data, 'base64');
let data1 : playerData = JSON.parse(buff.toString('utf-8'));
let player = game.lobbyState.findPlayer(socket.user.id)
player.inventory = data1.inventory
playerInventory.validate(player.inventory)
let player : playerData = socket.player
player.inventory.weapon = data1.inventory.weapon
player.inventory.equipment = data1.inventory.equipment
player.validateEquipment()
game.socketIO.emit("lobby/loadoutChanged", JSON.stringify(player))
});

4
Player/players.ts
View File

@ -1,5 +1,4 @@
import { game } from "../game";
import { userData } from "../Classes/userData";
import { playerData } from "../Classes/playerData";
const fs = require('fs');
@ -34,13 +33,14 @@ export class players{
files.forEach(file => {
fs.readFile(`Database/Players/${file}`, (err, data) => {
if (err) throw err;
let player : playerData = JSON.parse(data);
let player : playerData = new playerData(JSON.parse(data));
game.playersDB.push(player);
player.inventory.items.forEach(i=>{
if(i.id > game.itemCount){
game.itemCount = i.id
}
})
player.validateEquipment()
console.log(`Loaded pl ${player.id}`);
});
});

11
game.ts
View File

@ -2,6 +2,7 @@ import { userData } from "./Classes/userData";
import { lobbyMessage } from "./Classes/lobbyMessage";
import { lobbyState } from "./Classes/lobbyState";
import { playerData } from "./Classes/playerData";
import { persistentItemData } from "./Classes/itemData";
const fs = require('fs');
export class game{
@ -10,6 +11,7 @@ export class game{
static itemCount : number = 0
static accountsDB : userData[] = []
static playersDB : playerData[] = []
static itemsDB : persistentItemData[] = []
/** Key: socket ID*/
static lobbyState : lobbyState = new lobbyState()
@ -25,4 +27,13 @@ export class game{
game.messages.unshift(message)
game.socketIO.emit('lobby/messages', JSON.stringify(game.messages))
}
static getItemTemplate(templateId){
let item = this.itemsDB.find(i=>i.id == templateId)
if (item == null){
console.log("Error, item " + templateId + " not found")
return null
}
return item
}
}

11
index.ts
View File

@ -1,10 +1,10 @@
import { registerAccountCallbacks } from "./Account/accountSocket";
import { users } from "./Account/users";
import { registerLobbyCallbacks } from "./Lobby/lobbySocket";
import { playerData } from "./Classes/playerData";
import { game } from "./game";
import { registerItemCallbacks } from "./Items/itemSocket";
import { users } from "./Account/users";
import { loadItems } from "./Items/items";
import { players } from "./Player/players";
import { registerItemCallbacks } from "./Items/itemSocket";
import { registerLobbyCallbacks } from "./Lobby/lobbySocket";
import { registerAccountCallbacks } from "./Account/accountSocket";
const express = require("express");
const app = express();
@ -24,6 +24,7 @@ const io = require("socket.io")(server, {
users.loadUsers();
players.loadPlayers();
loadItems()
io.on('connection', (socket) => {
console.log("Got connection!");