Move card server logic test into cardGen.js module
parent
57b0194f9b
commit
ceef95712e
@ -0,0 +1,373 @@
|
|||||||
|
// Need to require DB again. Apparently this is ok, as it'll
|
||||||
|
// still only have one require cross project (?)
|
||||||
|
const database = require('./database');
|
||||||
|
|
||||||
|
|
||||||
|
// cardClass, cardColourRequirement
|
||||||
|
// may want to be seperate too (as well as in cardItem), so that
|
||||||
|
// during match they can be altered by effects while keeping the OG card
|
||||||
|
// for inspecting (and compare against new stats,reqs,etc.)
|
||||||
|
// same with attack, cost, etc. things that will can be visually shown as
|
||||||
|
// changed in game
|
||||||
|
|
||||||
|
// Just grabbing everything from DB for now, as it's quite small at current
|
||||||
|
// then will rejig when needed.
|
||||||
|
// Should all cards, effects, classes etc. be loaded in on server start
|
||||||
|
// then just load decks and decklists when needed?
|
||||||
|
function getDecks(deckId, playerId, item = [], deckItem = {}){
|
||||||
|
// Await promise, once it's done get the data, if errors send err
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
|
||||||
|
database.dbGetDecks().then(data => {
|
||||||
|
|
||||||
|
let decks = [];
|
||||||
|
|
||||||
|
data.forEach((deck) => {
|
||||||
|
//let itemId = item.length;
|
||||||
|
//item.push(itemId); // Add the next available item
|
||||||
|
// Add the deck info to deckItem
|
||||||
|
// deckItem[itemId] = {};
|
||||||
|
decks.push({
|
||||||
|
'deckId': deck.deckId,
|
||||||
|
'playerId': deck.playerId,
|
||||||
|
'deckName': deck.deckName,
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// Resolve the decks pulled
|
||||||
|
resolve(decks);
|
||||||
|
|
||||||
|
//console.log(item);
|
||||||
|
//console.log(deckItem);
|
||||||
|
//console.log(decks);
|
||||||
|
})
|
||||||
|
.catch(err => { throw err; })
|
||||||
|
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
//getDecks();
|
||||||
|
function getDeckList(){
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
|
||||||
|
database.dbGetDeckList().then(data => {
|
||||||
|
|
||||||
|
let deckList = [];
|
||||||
|
|
||||||
|
data.forEach((listItem) => {
|
||||||
|
// Add the deck info to deckItem
|
||||||
|
deckList.push({
|
||||||
|
'deckId': listItem.deckId,
|
||||||
|
'playerId': listItem.playerId,
|
||||||
|
'cardId': listItem.cardId,
|
||||||
|
'cardCount': listItem.cardCount,
|
||||||
|
});
|
||||||
|
resolve(deckList);
|
||||||
|
});
|
||||||
|
})
|
||||||
|
.catch(err => { throw err; })
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
//getDeckList();
|
||||||
|
function getCards(){
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
|
||||||
|
database.dbGetCards().then(data => {
|
||||||
|
|
||||||
|
let cards = [];
|
||||||
|
|
||||||
|
data.forEach((card) => {
|
||||||
|
cards.push({
|
||||||
|
'id': card.id,
|
||||||
|
'cardName': card.cardName,
|
||||||
|
'cardCost': card.cardCost,
|
||||||
|
'cardType': card.cardType,
|
||||||
|
'cardAttack': card.cardAttack,
|
||||||
|
'cardRarity': card.cardRarity,
|
||||||
|
'cardClass': [],
|
||||||
|
'cardColourRequirement': [],
|
||||||
|
});
|
||||||
|
});
|
||||||
|
resolve(cards);
|
||||||
|
})
|
||||||
|
.catch(err => { throw err; })
|
||||||
|
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
//getCards();
|
||||||
|
function getCardClasses(){
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
database.dbGetCardClasses().then(data => {
|
||||||
|
|
||||||
|
let cardClasses = [];
|
||||||
|
|
||||||
|
data.forEach((cardClass) => {
|
||||||
|
|
||||||
|
cardClasses.push({
|
||||||
|
'cardId': cardClass.cardId,
|
||||||
|
'classId': cardClass.classId,
|
||||||
|
});
|
||||||
|
|
||||||
|
});
|
||||||
|
resolve(cardClasses);
|
||||||
|
})
|
||||||
|
.catch(err => { throw err; })
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
//getCardClasses();
|
||||||
|
function getCardColourRequirement(){
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
database.dbGetCardColourRequirement().then(data => {
|
||||||
|
|
||||||
|
let colourRequirements = [];
|
||||||
|
|
||||||
|
data.forEach((cardColourReq) => {
|
||||||
|
|
||||||
|
colourRequirements.push({
|
||||||
|
'cardId': cardColourReq.cardId,
|
||||||
|
'colourId': cardColourReq.colourId,
|
||||||
|
'cost': cardColourReq.cost,
|
||||||
|
});
|
||||||
|
|
||||||
|
});
|
||||||
|
resolve(colourRequirements);
|
||||||
|
|
||||||
|
})
|
||||||
|
.catch(err => { throw err; })
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
//getCardColourRequirement();
|
||||||
|
// Then effects which will have effects with parent triggers, and unit type checks
|
||||||
|
// colour checks, all sorts. So will be more difficult. Basic (flight, etc)
|
||||||
|
// shouldn't be too bad
|
||||||
|
// something like effect_basic, card_effect, effect_trigger, effect_requirement, effect_option
|
||||||
|
// effect_stage, effect_advanced, with advanced being an id with x triggers, triggers have
|
||||||
|
// x req, advanced as with x options, x stages to be able to fine-tune fancy stuff
|
||||||
|
// combining all other effects, units, cards, colours, etc. Will be a lot of though,
|
||||||
|
// but better than hard coding anything more than basic effects and effect check logic
|
||||||
|
// TODO: effect (as above)
|
||||||
|
|
||||||
|
// request a deck in the format CURRENTLY used in the game
|
||||||
|
// decks will likely be changed around
|
||||||
|
|
||||||
|
// https://www.geeksforgeeks.org/how-to-wait-for-multiple-promises-in-javascript/
|
||||||
|
// https://medium.com/@nikolozz/using-socket-io-with-async-await-13fa8c2dc9d9
|
||||||
|
// using last example
|
||||||
|
function requestDeck(socket, playerId, deckId){
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
(async () => {
|
||||||
|
|
||||||
|
// Get the deck(s) requested.
|
||||||
|
// Not 100% on how to do two differening atm
|
||||||
|
// Besides all of playerId, and all of deckId. But 1,2/2,3 for instance
|
||||||
|
const [decks, deckList] =
|
||||||
|
await Promise.all([
|
||||||
|
getDecks(),
|
||||||
|
getDeckList()
|
||||||
|
// Don't need to do this for each when awaiting all
|
||||||
|
// Instead it'll wait until each is done, set the data to the const
|
||||||
|
// Then do the stuff after the variable's are set!!
|
||||||
|
/*
|
||||||
|
getDecks().then(data => {
|
||||||
|
//console.log(data);
|
||||||
|
}).catch(err => { throw err; }),
|
||||||
|
*/
|
||||||
|
|
||||||
|
]);
|
||||||
|
|
||||||
|
//console.log(decks);
|
||||||
|
//console.log(deckList);
|
||||||
|
// Now loop the deckList for the cardIds
|
||||||
|
let deckCardIds = [];
|
||||||
|
deckList.forEach((deckItem) => {
|
||||||
|
deckCardIds.push(deckItem.cardId);
|
||||||
|
|
||||||
|
});
|
||||||
|
//console.log(deckCardIds);
|
||||||
|
|
||||||
|
// Next, get the cards in the deck by their ID
|
||||||
|
// TODO: https://stackoverflow.com/a/65510676
|
||||||
|
// Change SQL to accept for just the cards passed
|
||||||
|
|
||||||
|
// Get each cards data, colourReqs, and classes
|
||||||
|
const [cards, cardClasses, cardColourRequirements] =
|
||||||
|
await Promise.all([
|
||||||
|
getCards(),
|
||||||
|
getCardClasses(),
|
||||||
|
getCardColourRequirement(),
|
||||||
|
]);
|
||||||
|
// ^^^^ Classes async? Can pass the cardsIds, then loop classes, if the class cardId
|
||||||
|
// matches the cardId in cards[] then push the class to cards[x].classes
|
||||||
|
|
||||||
|
// TODO: Build the card so far async for it's done alongside getting effects?
|
||||||
|
// Then when both done add the effects to the existing cardObjects? Yep good idea me
|
||||||
|
//console.log(cards);
|
||||||
|
//console.info(cardClasses);
|
||||||
|
//console.log(cardColourRequirements);
|
||||||
|
|
||||||
|
const [builtCards] =
|
||||||
|
await Promise.all([
|
||||||
|
buildCards(cards, cardClasses, cardColourRequirements),
|
||||||
|
// TODO: builtEffects
|
||||||
|
]);
|
||||||
|
|
||||||
|
//console.log(builtCards);
|
||||||
|
// TODO: addEffectsToCards
|
||||||
|
// TODO: Finally do the effects for each card. This will be the complicater
|
||||||
|
// since it's not 100% thought out yet... (
|
||||||
|
|
||||||
|
// Add the cards (x of how many cardObjects with cardId are in count in decklist)
|
||||||
|
// to a deck array to pass through. Or decks array with deckId specified?
|
||||||
|
//console.log(deckList);
|
||||||
|
// These are the four basic fellas for this
|
||||||
|
// from public/board.js where current game testing/logic is applied
|
||||||
|
// So creating as a test for a 'room' to see if it's simple enough to
|
||||||
|
// send and play with
|
||||||
|
// BUILD THE DATA TO SEND TO CLIENTS! (Kinda)
|
||||||
|
let item = [];
|
||||||
|
let itemCount = 0;
|
||||||
|
let deckData = {}; // New but may be useful
|
||||||
|
let deckIn = {}; // Which deck the item is in? Kinda the player/boardelement thing?
|
||||||
|
let cardData = {};
|
||||||
|
let boardElement = {};
|
||||||
|
// TODO: Set the player. For now will do this in front-end as testing currently
|
||||||
|
|
||||||
|
// Loop and create the deck first
|
||||||
|
//console.log(decks);
|
||||||
|
decks.forEach((deck) => {
|
||||||
|
item.push(itemCount); // Add new item to add stuff for
|
||||||
|
deckData[itemCount] = {'deckId':deck.deckId, 'playerId':deck.playerId, 'deckName':deck.deckName};
|
||||||
|
boardElement[itemCount] = 'realDeck';
|
||||||
|
itemCount++;
|
||||||
|
})
|
||||||
|
console.log(deckData);
|
||||||
|
console.log(deckList);
|
||||||
|
|
||||||
|
// Loop each item in the deckList
|
||||||
|
// Loop inside it X times where X is cardCount
|
||||||
|
// Add the builtCard with same cardId as deckList item X times
|
||||||
|
deckList.forEach((deckListItem) => {
|
||||||
|
|
||||||
|
let deckItem = null;
|
||||||
|
// Loop each deck, if the deck/playerIds match, add association
|
||||||
|
for(key in deckData){
|
||||||
|
//Object.keys(deckData).forEach(function(key) { // Less efficient than for
|
||||||
|
// Needs to check deck AND player id, as that's the primary key (together)
|
||||||
|
if(deckData[key].deckId == deckListItem.deckId && deckData[key].playerId == deckListItem.playerId){
|
||||||
|
deckItem = key; // Key is the `item` key
|
||||||
|
}
|
||||||
|
|
||||||
|
};
|
||||||
|
// For each new card, loop to the cardCount (how many cards in deck)
|
||||||
|
// and add to the deck
|
||||||
|
for(let i = 0; i < deckListItem.cardCount; i++){
|
||||||
|
item.push(itemCount); // Add new item to add stuff for
|
||||||
|
// ^ not using item.length incase anything in future gets deleted
|
||||||
|
// from item for instance
|
||||||
|
cardData[itemCount] = builtCards[deckListItem.cardId]; // builtCards id set to cardId from DB, so adding the builtCard object is based on the deckList's cardId (from DB)
|
||||||
|
boardElement[itemCount] = 'deck'; // Add all cards to deck at match start
|
||||||
|
// Associate the card with the deck
|
||||||
|
// TODO: Change deckIn to something more sensical
|
||||||
|
deckIn[itemCount] = deckItem;
|
||||||
|
itemCount++; // Increment item to not overwrite
|
||||||
|
}
|
||||||
|
|
||||||
|
});
|
||||||
|
|
||||||
|
// item, itemCount, deckData, cardData, boardElement
|
||||||
|
//console.log(cardData);
|
||||||
|
|
||||||
|
// Returning everything to be looped in the front-end
|
||||||
|
// This won't be looped as it will at final, instead just for deck generation
|
||||||
|
// Returned as object over array, as easier to disect when gets to front-end
|
||||||
|
let dataReturn = {
|
||||||
|
item: item,
|
||||||
|
itemCount: itemCount,
|
||||||
|
deckData: deckData,
|
||||||
|
deckIn: deckIn,
|
||||||
|
cardData: cardData,
|
||||||
|
boardElement: boardElement,
|
||||||
|
};
|
||||||
|
return resolve(dataReturn);
|
||||||
|
//return resolve(cardData);
|
||||||
|
|
||||||
|
// Promise stuff testing
|
||||||
|
})()
|
||||||
|
});
|
||||||
|
|
||||||
|
// TODO: In future the item inc. all the decks, cards, locations, and other attributes
|
||||||
|
// will come from here
|
||||||
|
|
||||||
|
// TODO: unrelated, but thought. If lots of players on, generating cards each time
|
||||||
|
// will be a big hit, as well as all the DB hits, so may need to load all cardObjects
|
||||||
|
// into memory/array when server starts. This then prevents any DB changes to alter
|
||||||
|
// things, but outside of testing that won't occur(?), may need to test this at some
|
||||||
|
// point to see. For now DB, and generating is ok, as still working on it
|
||||||
|
}
|
||||||
|
|
||||||
|
function buildCards(cards, cardClasses, cardColourRequirements){
|
||||||
|
|
||||||
|
const dPromise = new Promise((resolve, reject) => {
|
||||||
|
|
||||||
|
builtCards = {};
|
||||||
|
|
||||||
|
//console.log(cards);
|
||||||
|
// Loop the cards and build the base
|
||||||
|
cards.forEach((card) => {
|
||||||
|
|
||||||
|
let builtCard = {
|
||||||
|
id: card.id,
|
||||||
|
name: card.cardName,
|
||||||
|
colour: [],
|
||||||
|
cost: card.cardCost,
|
||||||
|
costReq: [],
|
||||||
|
type: card.cardType,
|
||||||
|
atk: card.cardAttack,
|
||||||
|
rarity: card.cardRarity,
|
||||||
|
effect: [],
|
||||||
|
cardClass: [],
|
||||||
|
};
|
||||||
|
// Give the card an easily accessible Id for compares
|
||||||
|
// and to add to the cardItem being built
|
||||||
|
builtCards[card.id] = builtCard;
|
||||||
|
|
||||||
|
});
|
||||||
|
//console.log(builtCards);
|
||||||
|
|
||||||
|
// Next loop each class, and add to the new builtCard (if cardIds match)
|
||||||
|
cardClasses.forEach((cardClass) => {
|
||||||
|
|
||||||
|
// Check the card exists (it should always, but don't want jank)
|
||||||
|
if(cardClass.cardId in builtCards){
|
||||||
|
// It's the Id for now
|
||||||
|
// TODO: Send the text too (from join) but don't use for compares
|
||||||
|
//console.log(cardClass.cardId);
|
||||||
|
//console.log(cardClass.classId);
|
||||||
|
//console.log('---');
|
||||||
|
//console.log(builtCards[cardClass.cardId]);
|
||||||
|
|
||||||
|
// Add the class to the class array (cards can have multiple)
|
||||||
|
builtCards[cardClass.cardId].cardClass.push(cardClass.classId);
|
||||||
|
|
||||||
|
// TODO: As an array [classId, className] then
|
||||||
|
// card.classes[x][0] can be compared as numeric in code
|
||||||
|
}
|
||||||
|
|
||||||
|
});
|
||||||
|
|
||||||
|
resolve(builtCards);
|
||||||
|
|
||||||
|
});
|
||||||
|
return dPromise;
|
||||||
|
}
|
||||||
|
// TODO: Add the effects onto the cards passed through
|
||||||
|
// Takes cards array (of obj), and array of effects (from DB or built, probabaly pre-built?)
|
||||||
|
function addCardsEffects(){}
|
||||||
|
|
||||||
|
module.exports = {
|
||||||
|
requestDeck
|
||||||
|
};
|
||||||
Loading…
Reference in New Issue