[DNM] Battle Mechanic update

controllers/actions-controller.js

@@ -4,50 +4,160 @@ const Mob = require('../models/mob');
 const mobsController = require('./mobs-controller');
 ////And the log model
 const Log = require('../models/log');
+////And the battle model
+const Battle = require('../models/battle');
+
 ////Create the actions controller object
 const actionsController = {};
 
 ////Give it logic
+/* XXX Trying this shit again.*/
 //attacking
+//actionsController.attack = function(req, res){
+//	//First make sure that both parties are in the same battle...
+//	Battle.confirmCompatibleCombatants(req.params.attacker, req.params.defender)
+//	.then(response => {
+//		if(response.length === 0){
+//			let error = {
+//				message: "Attack rejected: You and your target are not in a battle or in different battles."
+//			}
+//			throw error;
+//		}
+//		//...Then we grab the attacker(?) and request that the defender takes damage according to specified calculations...
+//		Mob.findById(req.params.attacker)
+//		.then(attacker => {
+//			return Mob.takeDamage(req.params.defender, attacker.attribute.strength)
+//			.then(defender => {
+//				let content = "";
+//				if (defender.attribute.living){
+//					content = `${attacker.name} attacks ${defender.name} for ${attacker.attribute.strength} damage! // ${attacker._id} =${attacker.attribute.strength}=> ${defender._id} //`;
+//				}
+//				//...But if the defender is already dead then don't do anything and throw and error.
+//				else if (defender.attackFailed){
+//					console.log('ERROR, CATCH!!!');
+//					let error = {};
+//					error.message = "Attack rejected: target is already downed and can't recieve anymore damage."
+//					throw error;
+//				}
+//				else {
+//					content = `${attacker.name} attacks ${defender.name} for ${attacker.attribute.strength} damage, knocking them to the ground! // ${attacker._id} =x!${attacker.attribute.strength}!x=> ${defender._id} //`;
+//				}
+//				//Log the action for future reference...
+//				let newLog = {
+//					content,
+//					timestamp: Date.now(),
+//					type: "action",
+//					room: null
+//				}
+//				return Log.create(newLog)
+//				.then(logResponse => {
+//					res.status(200)
+//					.json({
+//						message: "Attack completed successfully!",
+//						log: logResponse,
+//						attacker,
+//						defender,
+//					})
+//				})
+//			})
+//		})
+//	})
+//	//General catchall
+//	.catch(err => {
+//		console.log(err)
+//		res.status(500).json({error: err})
+//	})
+//}
+
 actionsController.attack = function(req, res){
-	Mob.findById(req.params.attacker)
-	.then(attacker => {
-		return Mob.takeDamage(req.params.defender, attacker.attribute.strength)
-		.then(defender => {
-			let content = "";
-			if (defender.attribute.living){
-				content = `${attacker.name} attacks ${defender.name} for ${attacker.attribute.strength} damage! // ${attacker._id} =${attacker.attribute.strength}=> ${defender._id} //`;
-			}
-			else if (defender.attackFailed){
-				console.log('ERROR, CATCH!!!');
-				let error = {};
-				error.message = "Attack rejected: target is already downed and can't recieve anymore damage."
-				throw error;
+	//See if the combatants are in the same battle.
+	Battle.confirmCompatibleCombatants(req.params.attacker, req.params.defender)
+	.then(response => {
+		if (response.length === 0){
+			let error = {
+				message: "Attack rejected: characters are not in the same battle"
 			}
-			else {
-				content = `${attacker.name} attacks ${defender.name} for ${attacker.attribute.strength} damage, knocking them to the ground! // ${attacker._id} =x!${attacker.attribute.strength}!x=> ${defender._id} //`;
-			}
-			let newLog = {
-				content,
-				timestamp: Date.now(),
-				type: "action",
-				room: null
-			}
-			return Log.create(newLog)
-			.then(logResponse => {
-				res.status(200)
-				.json({
-					message: "Attack completed successfully!",
-					log: logResponse,
-					attacker,
-					defender,
+			throw error;
+		}
+		else {
+			//Grab both the attacker and the defender
+			return Promise.all([Mob.findById(req.params.attacker), Mob.findById(req.params.defender)])
+			.then(promiseResponse => {
+				//Find the attacker in the battle...
+				for (let combatant in response[0].combatants){
+					if (response[0].combatants[combatant].mobId === req.params.attacker){
+						//If it's not their turn, stop the attack
+						if (response[0].combatants[combatant].turnCount !== 0){
+							let error = {
+								message: "Attack rejected: not the character's turn"
+							}
+							throw error;
+						}
+						//If it is, then we update the battle with an increased turn count for the attacker
+						response[0].combatants[combatant].turnCount += 50 - (promiseResponse[0].attribute.agility * 2)
+						//Battle.update(response[0])
+						break;
+					}
+				}
+				//Then we find who is next in line for attacking
+				let lowest = response[0].combatants[0].turnCount;
+				console.log('finding next in line...');
+				for (let combatant in response[0].combatants){
+					if (response[0].combatants[combatant].turnCount < lowest){
+						lowest = response[0].combatants[combatant].turnCount;
+						console.log('...new lowest found...');
+					}
+				}
+				//...And finally progress everyone's turn timer
+				for (let combatant in response[0].combatants){
+					response[0].combatants[combatant].turnCount -= lowest;
+					console.log('buzz!');
+				}
+				//Apply the update
+				Battle.update(response[0])
+
+				//Deal damage based on the attacker's strength 
+				return Mob.takeDamage(req.params.defender, promiseResponse[0].attribute.strength)
+				.then(postDamageResponse => {
+					//Check if the attack failed
+					if (postDamageResponse.attackFailed){
+						console.log('ERROR, CATCH!!!');
+						let error = {};
+						error.message = "Attack rejected: target is already downed and can't recieve anymore damage.";
+						throw error;
+					}
+
+					//Build the log message
+					let content = "";
+					if (promiseResponse[1].attribute.living){
+						content = `${promiseResponse[0].name} attacks ${promiseResponse[1].name} for ${promiseResponse[0].attribute.strength} damage! // ${promiseResponse[0]._id} =${promiseResponse[0].attribute.strength}=> ${promiseResponse[1]._id} //`;
+					}
+					else {
+						content = `${promiseResponse[0].name} attacks ${promiseResponse[1].name} for ${promiseResponse[0].attribute.strength} damage, knocking them to the ground!! // ${promiseResponse[0]._id} =x${promiseResponse[0].attribute.strength}x=> ${promiseResponse[1]._id} //`;
+					}
+					//build the log
+					let newLog = {
+						content,
+						timestamp: Date.now(),
+						type: "action",
+						room: null
+					}
+					return Log.create(newLog)
+					.then(logResponse => {
+						res.status(200)
+						.json({
+							message: "Attack completed successfully!",
+							log: logResponse,
+							attacker: promiseResponse[0],
+							defender: promiseResponse[1]
+						})
+					})
 				})
 			})
-		})
-	})
-	.catch(err => {
+		}
+	}).catch(err => {
 		console.log(err)
-		res.status(500).json({error: err})
+		res.status(500).json(err)
 	})
 }
 

controllers/battle-controller.js

@@ -0,0 +1,73 @@
+//Import the battle model
+const Battle = require('../models/battle');
+//And the Mob model too.
+const Mob = require('../models/mob');
+//Might need the log model too
+const Log = require('../models/log');
+
+//Create the battlesController object
+const battlesController = {};
+
+//TODO: Maybe we can have a controller helper in the same way we have a model helper to avoid CRUD function regurgitation??
+//Short information about all battles
+battlesController.index = function(req, res){
+	Battle.findAll()
+	.then(battles => {
+		res.status(200)
+		.json({
+			message: "Battle index retrieved successfully!",
+			battles
+		})
+	}).catch(err => {
+		console.log(err);
+		res.status(500).json({error: err});
+	})
+}
+
+//in depth information about a single battle
+battlesController.show = function(req, res){
+	Battle.findById(req.params.id)
+	.then(battle => {
+		res.status(200)
+		.json({
+			message: "Battle retrieved successfully!",
+			battle
+		})
+	}).catch(err => {
+		console.log(err);
+		res.status(500).json({error: err});
+	})
+}
+
+//Creating a new battle
+battlesController.create = function(req, res){
+	Battle.create(req.body)
+	.then(battle => {
+		res.status(201)
+		.json({
+			message: "Battle created successfully!",
+			battle
+		})
+	}).catch(err => {
+		console.log(err);
+		res.status(500).json({error: err});
+	})
+}
+
+//Adding combatants to an existing battle
+battlesController.addToBattle = function(req, res){
+	Battle.insertIntoCombatants(req.params.id, req.body)
+	.then(battle => {
+		res.status(200)
+		.json({
+			message: "Combatant added to battle successfully!",
+			battle
+		})
+	}).catch(err => {
+		console.log(err);
+		res.status(500).json({error: err});
+	})
+}
+
+//Export the file
+module.exports = battlesController

db/migrations/migration-00003.js

@@ -0,0 +1,45 @@
+db = new Mongo().getDB('psg');
+db.createCollection('battles', {
+	validationLevel: "strict",
+	validator: {
+		$jsonSchema: {
+			bsonType: "object",
+			required: ["active","currentTurn","turnTimer","combatants"],
+			additionalProperties: false,
+			properties: {
+				_id: {
+					bsonType: "objectId"
+				},
+				//Going to skimp out on the descriptions for now, they have no purpose.
+				active: {
+					bsonType: "bool"
+				},
+				currentTurn: {
+					bsonType: "string"
+				},
+				turnTimer: {
+					bsonType: "int"
+				},
+				combatants: {
+					bsonType: "array",
+					items: {
+						bsonType: "object",
+						required: ["mobId", "turnCount", "team"],
+						additionalProperties: false,
+						properties: {
+							mobId: {
+								bsonType: "string"
+							},
+							turnCount: {
+								bsonType: "int"
+							},
+							team: {
+								bsonType: "int"
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+});