diff --git a/public/board.js b/public/board.js index 2db6ae7..8023be2 100644 --- a/public/board.js +++ b/public/board.js @@ -651,6 +651,34 @@ class Board{ } } + playRecruitedCard(player, fromPositionInHand){ + + // Check there's space on the board/mana zone/shield/etc + if(!this.hasSpaceInBoardElement('board', player)){ + alert('No space on board'); + return false; + } + + // Summon card to board from... + this.summonCard(player, fromPositionInHand, 'hand', player); + + // TODO: Check triggers for 'when X recruits' and add to queue + + this.drawBoard(); + + } + + summonCard(fromPlayer, positionFrom, fromElement, toPlayer){ + + // Summon card to board from... + this.addFromBoardElement(fromPlayer, positionFrom, fromElement, 'board', null, toPlayer); + + // TODO: Check triggers on 'when X summons'/'when a X is summoned' and add to queue + + this.drawBoard(); + + } + // Currently only functionality in hand playCardToBoard(positionFrom, fromElement, toElement, fromPlayer, toPlayer = null, cardsToPlay = 1){ @@ -691,8 +719,7 @@ class Board{ } } - // Move from player0, position 0 (top) of deck, to hand, to pos(null/auto) for toPlayer - this.addFromBoardElement(fromPlayer, positionFrom, fromElement, toElement, null, toPlayer); + this.summonCard(fromPlayer, positionFrom, fromElement, toPlayer); } this.drawBoard(); diff --git a/public/debug.js b/public/debug.js index da47f48..6074130 100644 --- a/public/debug.js +++ b/public/debug.js @@ -165,7 +165,9 @@ function debugEffectCanTrigger(){ if(doEffectTriggers(ecTriggerTargetId, ecTriggerIndex, true) != true){ console.log('Effect cannot be triggered'); - doEffect(ecTriggerTargetId, ecTriggerIndex, 1); + queueEffect(ecTriggerTargetId, ecTriggerIndex); + //doNextInQueue(); + loopTriggerQueue(); return false; } @@ -175,8 +177,8 @@ function debugEffectCanTrigger(){ // Do everything needed in triggers doEffectTriggers(ecTriggerTargetId, ecTriggerIndex); - // Then do the actual effects - doEffect(ecTriggerTargetId, ecTriggerIndex); // also step = 1,2,3 + // Then queue the effects to happen (queued so they can be chained/countered) + queueEffect(ecTriggerTargetId, ecTriggerIndex); } } diff --git a/public/effect.js b/public/effect.js index ae3805f..a006713 100644 --- a/public/effect.js +++ b/public/effect.js @@ -1,9 +1,22 @@ +// Theorising, if this is what's wanted then will need doing for everything +// not just in effects. eg. 'attack', 'effect1p1', 'flip', yadda yadda +let triggerQueue = []; +let triggerId = 1; // So any other effects, etc. queued for a destroyed card can be removed at once +let triggerDone = []; // The triggers that have completed +let triggerQueueTargets = []; // Whatever was targetted by the effect, etc. in triggerQueue (for ref by effectStep, etc) + // Passive effects (just does stuff) let flight = {}; let reach = {}; let equipped = {}; // Entity x has [a,b,c] equipped to it +// Events (when these occur check if this is part of an effect trigger) +// startOfGame, startOfTurn, endOfTurn +// cardSummoned, cardRecruited, effectTriggered +// etc. + + // Trigger types const triggerTypes = { 'tap': 1, @@ -283,7 +296,7 @@ function getEffect(itemKey, effectIndex){ } // Get all the targets for effect step, so they can be targgeted // by the effect/selected by the player -function getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement, playerId){ +function getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement, playerId, effectTriggerId = null){ // Get Effect let effect = getEffect(itemKey, effectIndex); @@ -303,24 +316,71 @@ function getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement // TODO: Not 100% sure how to keep track. May need a var for each item in previous steps // or previous chains so they can be accessed, and used // If itemFromStep, return the itemKeys of the items selected from a previous step - /* - if(target['itemFromStep'] == null){ - // So something from step 1 needs to be selected by this. + + console.log('HELLOO'); + console.log(step['target']); + + // TODO: If target is 'itemFromStep', then get whatever item(s) were selected in + // said step, and add them to the thing + // TODO TODO + + // If the target requirement is something from a previous step + // Check if target criteria is something from another step + let isFromStep = false; + step['target'].forEach((target) => { + if(target['itemFromStep'] != null){ + + console.log(target['itemFromStep']); + console.log(effectTriggerId); + //console.log(triggerQueue); + //console.log(triggerDone); + + // Loop all triggers that have been done (completed) + triggerDone.forEach((oldTrigger) => { + + // If not same triggerId, or the effectStep is not that of itemFromStep + if(oldTrigger['triggerId'] != effectTriggerId || target['itemFromStep'] != oldTrigger['effectStep']){ + return isFromStep = false; + } + + console.log(oldTrigger); + return isFromStep = oldTrigger['targets']; + + }); + + } + + }); + // If above returns a step, need to get the target(s) from that prior step to use a targets now + if(isFromStep){ + console.log(isFromStep); + console.log('AAAAAAAAAAAAAAAAAAAAAA'); } - */ - + + let items = []; + // If from a previous step, loop those + if(isFromStep !== null && isFromStep !== undefined && isFromStep !== false){ items = isFromStep; } + // If not, get all the related doodads + else{ + items = board.getItems(fromBoardElement, playerId, null, null); + } + + // Loop the boardlements and compare the colours, classes, etc. to match effect target criteria // boardElement, playerId, cardStatus, listPosition - let items = board.getItems(fromBoardElement, playerId, null, null); // TODO: maybe 'from top of deck, or if tapped' for(let item = 0; item < items.length; item++){ // TODO: MAYBE ADD THE COLOUR/PASSIVE CHECKS to the getItems itself let itemKey = items[item]; - console.log(cardColours[itemKey]); + //console.log(cardColours[itemKey]); // If the item from getItems meets the criterias of target DB step['target'].forEach((target) => { + //console.log(target); + //console.log(triggerDone); + + // Check the class the same for target, and item // If targetDB has null this means 'any' so is always correct // Check Class (TODO: mixed classes, colours, etc ie select 1 red+blue card) @@ -370,11 +430,102 @@ function getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement } +function addTargettedCardsToQueueEvent(queueTriggerId, triggerStep, targets){ + + console.log('ADD TARGETTED TO QUEUED TRIGGER'); + console.log(queueTriggerId); + console.log(triggerStep); + console.log(targets); + + //console.log(triggerQueue[queueTriggerId]); + //console.log(targets); + + console.log(triggerQueue); + + triggerQueue.forEach((queued) => { + console.log(queued); + if( + queued.triggerId == queueTriggerId + && + queued.effectStep == triggerStep + ){ + console.log('THIS SHOULD HAVE TARGETS ADDED'); + queued['targets'] = targets; + } + }); + + console.log(triggerQueue); + +} + + +function queueEffect(itemKey, effectIndex){ + + let effect = getEffect(itemKey, effectIndex); + if(effect == false){ return false; } + + // TODO: Sort steps by stepOrder incase wrong in DB, etc. + for (const [stepKey, step] of Object.entries(effect['step'])) { + triggerQueue.push( + // event, item, effectId, target, triggerId (commented atop) + { + 'event': 'effect' // Which event. attack, destroy, effect, etc. + ,'item': itemKey // Which card is doing event + ,'effectIndex': effectIndex // Which effect (if effect) + ,'effectStep': stepKey // Which effect (if effect) + ,'target': null // ? + ,'triggerId': triggerId + ,'targets': null // ? + } + ); + } + // Increment triggerId + triggerId++; + console.log(triggerQueue); +} + +function doNextInQueue(){ + + if(triggerQueue.length <= 0){ + console.log('Nothing in queue, doing next phase/event/whatever'); + } + + // If effect, trigger it (should already have paid the trigger costs) + switch(triggerQueue[0].event){ + case 'effect': + // Do the effect + doEffect(triggerQueue[0].item, triggerQueue[0].effectIndex, triggerQueue[0].effectStep, triggerQueue[0].triggerId); + break; + + default: + alert('Error in doNextInQueue'); + return 0; + break; + + + } + + // Add to completed triggers + triggerDone.push(triggerQueue[0]); + + // And remove from the triggerQueue (first index) + triggerQueue.shift(); + +} +function loopTriggerQueue(){ + + while(triggerQueue.length > 0){ + doNextInQueue(); + } + +} // Recusively call doEffect until each is done? // Once recruit (play from hand) is triggered, need to allow user to select // then when done move to next step -function doEffect(itemKey, effectIndex, effectStep = 1){ +function doEffect(itemKey, effectIndex, effectStep, effectTriggerId){ + + console.log('doEffect'); let effect = getEffect(itemKey, effectIndex); if(effect == false){ return false; } @@ -386,35 +537,98 @@ function doEffect(itemKey, effectIndex, effectStep = 1){ // For each step, activate the correct effect type on // the correct targets. + + + // Get targets TODO: Use this instead of each case having it + //let targets = getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement, playerId, effectTriggerId); switch (step['basicEffectId']){ // Recruit case 4: - recruitCard(itemKey, effectIndex, effectStep, step['amount']); + recruitCard(itemKey, effectIndex, effectStep, step['amount'], effectTriggerId); break; // Give Flight case 5: - console.log('GIVE FLIGHT'); + givePassive(itemKey, effectIndex, effectStep, step['amount'], effectTriggerId, 'flight'); break; } + // Add the selected targets to the queuedItem so it can be referred to in future + // Now do the next step, if there's another in the effect + // Commented out while testing triggerQueue + /* if(effect['step'][effectStep++] !== undefined){ doEffect(itemKey, effectIndex, effectStep++); } + */ +} + +function givePassive(itemKey, effectIndex, effectStep, targetAmount, effectTriggerId, passive){ + + console.log('GIVE PASSIVE: '+passive); + + let effect = getEffect(itemKey, effectIndex); + if(effect == false){ return false; } + + // Get the step + let step = effect['step'][effectStep]; + if(step == undefined){ return false; } + + console.log(step); + //return false; + + // TODO: null, 0 are boardElement/playerId (for now) need to redo, rethink + console.log('HELP ME'); + let targets = getEffectStepTargets(itemKey, effectIndex, effectStep, null, 0, effectTriggerId); + console.log(targets); + + if(targetAmount > 0 && targets.length > 0){ + + // TODO: better, and if just one thing omit, and do automatically + let selectedTarget = prompt("Select a card to gain flight: \n"+targets, targets[0]); + // User didn't select anything + if (selectedTarget == null || selectedTarget == "") { + alert('No card recruited, c ya'); + return false; + } + // User inputted card not in ID (obv temp, as will be done in game UI) + // Huh I forgot why this is written like this, maybe it doens't work? + if (!selectedTarget.includes(selectedTarget)){ + alert('Not in selection'); + return false; + } + + + // Remove the card from the selection (in case there's another in this loop) + targets.splice(targets.indexOf(selectedTarget), 1); + + // Give the passive + if(passive == 'flight'){ + giveFlight(selectedTarget); + } + + } + + } -function recruitCard(itemKey, effectIndex, effectStep, targetAmount){ +function removePassive(){} +function hasPassive(){} + +function recruitCard(itemKey, effectIndex, effectStep, targetAmount, effectTriggerId = null){ console.log('RECRUIT'); let fromBoardElement = 'hand'; // FOR NOW, JUST TO TEST, THIS WILL BE PER BASIC EFFECT let playerId = 0; - let targets = getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement, playerId); - console.log(targets); + let targets = getEffectStepTargets(itemKey, effectIndex, effectStep, fromBoardElement, playerId, effectTriggerId); + let targettedCards = []; + + //console.log(targets); if(targetAmount > 0 && targets.length > 0){ @@ -430,15 +644,19 @@ function recruitCard(itemKey, effectIndex, effectStep, targetAmount){ return false; } - // Remove the card from the selection + // Remove the card from the selection (in case there's another) targets.splice(targets.indexOf(selectedTarget), 1); + // Add to targetted (for future ref) + targettedCards.push(selectedTarget); + // Play recruited card - // TODO: Maybe needs a new function 'playRecruitedCard' for different event triggers - board.playCardToBoard(listPosition[itemKey], boardElement[itemKey], 'board', 0, 0, 1); + // TODO: Need to pass player/listPosition better? + board.playRecruitedCard(player[selectedTarget], listPosition[selectedTarget]); } + addTargettedCardsToQueueEvent(effectTriggerId, effectStep, targettedCards); }