카테고리 없음
6주차 (5)
jaeoun0238
2024. 12. 6. 21:18
function solution(arr, divisor) {
var answer = [];
for(i=0; i<arr.length; i++){
if(arr[i]%divisor === 0) {
answer.push(arr[i]);
}
}
if(answer.length===0){
answer.push(-1);
}
answer.sort((a,b)=>a-b)
return answer;
}SoccerSimulator
추가적으로 합치면서 코드 마무리!
import express, { request } from 'express';
import { prisma } from '../uts/prisma/index.js';
import errModel from '../middlewares/error.middleware.js';
import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import authMiddleware from '../middlewares/auth.middleware.js';
const router = express.Router();
// 회원가입api
/** 사용자 회원가입 API **/
router.post('/sign-up', async (req, res, next) => {
const { userID, userName, userPassword } = req.body;
try {
// 동일한 회원정보 확인하기
const sameUser = await prisma.userData.findUnique({
where: {
userID,
},
});
// 사용자 정보가 이미 존재하는 경우
if (sameUser) {
return res.status(409).json({ message: '이미 존재하는 유저입니다.' });
}
// 비밀번호 해시화 (변경된 부분)
const bcryptPassword = await bcrypt.hash(userPassword, 10); // salt rounds 추가
const players = await prisma.playerData.findMany({
take: 3,
});
const result = await prisma.$transaction(async (tx) => {
// 트랜잭션 내에서 사용자를 생성합니다.
const user = await tx.userData.create({
data: {
userID,
userName,
userPassword: bcryptPassword,
userScore: 1000,
userCash: 5000,
},
});
//스쿼드 만들기
const squard = await tx.playerSquadsData.create({
data: {
userPID: user.userPID,
},
});
for (let i = 0; i < players.length; i++) {
const player = players[i];
const defaultPlayer = await tx.playerRostersData.create({
data: {
userPID: user.userPID,
playerPID: player.playerPID,
playerEnchant: 0,
},
});
//playerPID를 이용해서 장착되게
const equipRoster = await tx.playerEquipRostersData.create({
data: {
playerSquadsPID: squard.playerSquadsPID,
playerRostersPID: defaultPlayer.playerRostersPID,
position: i,
},
});
// console.log(equipRoster);
}
// 에러가 발생하여, 트랜잭션 내에서 실행된 모든 쿼리가 롤백됩니다.
return user;
});
// userData 테이블에 사용자를 추가
return res.status(201).json({ message: '회원가입이 완료되었습니다.' });
} catch (err) {
next(err);
// 오류 처리 시작 (변경된 부분)
// console.error(error); // 오류 로그 출력 (변경된 부분)
// return res.status(500).json({ message: '서버 오류가 발생했습니다.' }); // 오류 응답 반환 (변경된 부분)
}
});
// 로그인api
/** 로그인 API **/
router.post('/sign-in', async (req, res, next) => {
const { userID, userPassword } = req.body;
const user = await prisma.userData.findUnique({ where: { userID } });
if (!user)
return res.status(401).json({ message: '존재하지 않는 유저입니다.' });
// 입력받은 사용자의 비밀번호와 데이터베이스에 저장된 비밀번호를 비교합니다.
else if (!(await bcrypt.compare(userPassword, user.userPassword)))
return res.status(401).json({ message: '비밀번호가 일치하지 않습니다.' });
// 로그인에 성공하면, 사용자의 userId를 바탕으로 토큰을 생성합니다.
// console.log(process.env.JWT_KEY);
const token = jwt.sign(
{
userPID: user.userPID,
},
process.env.JWT_KEY, // 비밀 키를 환경 변수에서 가져옴
{ expiresIn: '1h' }, // 토큰의 만료 시간을 설정 (1시간)
);
// 헤더로 주고받게 바꾸기
res.setHeader('authorization', `Bearer ${token}`);
return res.status(200).json({
message: '로그인 성공',
user: {
userID: user.userID,
},
});
});
// 캐시 구매
router.patch('/buyCash', authMiddleware, async (req, res, next) => {
try {
const { userPID } = req.user;
const { cash } = req.body;
// 현재 보유량 + 추가 캐시 하기위해 현재 user정보 가져옴
const user = await prisma.userData.findUnique({
where: { userPID: +userPID },
});
// cash가 존재하지 않으면 에러, middleware로 따로 빼도 됨
if (!cash) {
return res.status(400).json({ error: '캐시를 입력해 주세요.' });
}
// cash가 유효한 값인지 검사, middleware로 따로 빼도 됨
if (typeof cash !== 'number' || cash < 0) {
return res.status(400).json({ error: '유효한 캐시 값을 입력해 주세요.' });
}
// 캐시 추가해서 업데이트
const updateCash = await prisma.userData.update({
where: { userPID: +userPID },
data: { userCash: user.userCash + cash },
});
return res.status(200).json({ currentCash: updateCash.userCash });
} catch (err) {
next(err);
}
});
//유저 랭킹 조회
router.get('/user/rankings', async (req, res, next) => {
try {
const ranking = await prisma.userData.findMany({
select: {
userName: true,
userScore: true,
},
orderBy: {
userScore: 'desc',
},
take: 10,
});
let rank = 1;
const userRanking = ranking.map((user, index, array) => {
if (index > 0 && array[index - 1].userScore === user.userScore) {
return {
ranking: rank,
userName: user.userName,
Score: user.userScore,
};
}
rank = index + 1;
return {
ranking: rank,
userName: user.userName,
Score: user.userScore,
};
});
// console.log(userRanking);
return res.status(200).json({ rank: userRanking });
} catch (err) {
return res.status(500).json({ error: '서버 오류입니다.' });
}
});
export default router;import express from 'express';
import { prisma } from '../uts/prisma/index.js';
import { Prisma } from '@prisma/client';
import authMiddleware from '../middlewares/auth.middleware.js';
const maxHave_Rosters = 50; //보유할수 있는 최대값
const maxHave_Squads = 3; //장착 할수 있는 최대값
const max_positon = 1; //
const can_postions = [0, 1, 2]; // 0: striker, 1: midfielder, 2: defender
const router = express.Router();
router.patch(
//인증으로 userPID받아오기 팀에 집어넣는 로직
'/team/Set/:positionIndex/what/:playerRostersPID',
authMiddleware,
async (req, res, next) => {
const { positionIndex, playerRostersPID } = req.params;
const { userPID } = req.user;
try {
let data_temp = await equip(
+userPID,
+playerRostersPID,
+positionIndex,
next,
);
if (!data_temp) {
throw {
status: 404,
message: '전달받은 데이터가 없습니다. 형식에 주의 해주세요.',
};
}
return res
.status(201)
.json({ message: '팀에 성공적으로 배치했습니다!', data: data_temp });
} catch (err) {
next(err);
}
},
);
router.delete(
//인증으로 userPID받아오기 팀에서 빼는 거
'/team/Get/what/:playerRostersPID',
authMiddleware,
async (req, res, next) => {
const { playerRostersPID } = req.params;
const { userPID } = req.user;
try {
let data_temp = await Unequip(+userPID, +playerRostersPID, next);
return res
.status(201)
.json({ message: '팀에서 성공적으로 해제했습니다!', data: data_temp });
} catch (err) {
next(err);
}
},
);
//팀 선택창에서 해제 //인증으로 userPID받아오기
//팀 갱신
router.get('/team/Get/:userPID', async (req, res, next) => {
const { userPID } = req.params;
try {
const checkHaveRouter = await prisma.playerRostersData.findMany({
where: {
userPID: +userPID,
},
});
const squads = await prisma.playerSquadsData.findFirst({
where: {
userPID: +userPID,
},
include: {
playerEquipRostersData: {
include: {
playerRostersData: true,
},
},
},
});
//기본 적인 스쿼드 데이터
return res.status(201).json({
message: ' 팀 스쿼드 배치 보유 선수 현황입니다.',
data: { squads, checkHaveRouter },
});
} catch (err) {
next(err);
}
});
//전체 장착 용도 함수
const equip = async (userPID, playerRostersPID, postionData, next) => {
try {
if (postionData > can_postions.length) {
throw {
status: 400,
message: '포지션 형식에 주의 해주세요.',
};
}
//보유 하고있는 로스터 데이터
const checkHaveRouter = await prisma.playerRostersData.findFirst({
where: {
userPID: userPID,
playerRostersPID: playerRostersPID,
},
select: {
playerPID: true,
playerRostersPID: true,
},
});
// 현재 장착하고 있는 팀
const checkSquads = await prisma.playerSquadsData.findFirst({
where: {
userPID: +userPID,
},
include: {
playerEquipRostersData: {},
},
});
//스쿼드 찾기 나중에 다중 스쿼드로 구성하면 many로 받기
//스쿼드에 집어넣음
if (
!checkHaveRouter ||
!checkSquads ||
checkSquads.playerEquipRostersData.length >= maxHave_Squads
) {
throw {
status: 404,
message: '최대 장착중이거나 데이터가 없습니다.',
};
} else if (isUse(checkSquads.playerEquipRostersData, playerRostersPID, 1)) {
throw {
status: 404,
message: '이미 장착중입니다..',
};
} else if (isUse(checkSquads.playerEquipRostersData, postionData, 0)) {
throw {
status: 400,
message: '장착중인 포지션 입니다.',
};
}
//이제 db에 저장하는 트렌직션
//장착 테이블에 생성
const make_data = await prisma.playerEquipRostersData.create({
data: {
playerSquadsPID: checkSquads.playerSquadsPID,
playerRostersPID: checkHaveRouter.playerRostersPID,
position: postionData,
},
});
return make_data;
} catch (err) {
next(err);
}
};
const Unequip = async (userPID, playerRostersPID, next) => {
try {
//보유 하고있는 로스터 데이터
const checkHaveRouter = await prisma.playerRostersData.findMany({
where: {
userPID: userPID,
},
select: {
playerPID: true,
playerRostersPID: true,
},
});
const checkSquads = await prisma.playerSquadsData.findFirst({
where: {
userPID: +userPID,
},
include: {
playerEquipRostersData: {},
},
});
if (
!checkSquads.playerEquipRostersData.some(
(data) => data.playerEquipRostersPID === playerRostersPID,
)
) {
throw {
status: 404,
message: '지목하신 데이터가 없습니다.',
};
}
console.log(checkSquads);
//스쿼드 데이터 인클루드로 받아서 체크
if (!checkSquads || checkHaveRouter.length >= maxHave_Rosters) {
throw {
status: 404,
message: '최대 보유중 이거나 데이터가 없습니다.',
};
}
//삭제
await prisma.playerEquipRostersData.delete({
where: {
playerEquipRostersPID: playerRostersPID,
},
});
} catch (err) {
next(err);
}
};
// 장착중인 포지션 , 장착중 체크용도.
const isUse = (checkEquipRouter, indexData, statuse) => {
// 0 position 1 선수로스터아이디
switch (statuse) {
case 0:
return checkEquipRouter.some((data) => data.position === indexData);
case 1:
return checkEquipRouter.some(
(data) => data.playerRostersPID === indexData,
);
default:
return false;
}
};
export default router;import express from 'express';
import { PrismaClient } from '@prisma/client';
import authenticateJWT from '../middlewares/auth.middleware.js';
import { prisma } from '../uts/prisma/index.js';
const router = express.Router();
// 플레이어생성 api
router.post('/player/make', async (req, res, next) => {
try {
//body로 전달 받은 객체 구조분해할당
const {
playerPID,
playerName,
playerAbilityATCK,
playerAbilityDEFEND,
playerAbilityMOBILITY,
} = req.body;
await prisma.$transaction(async (tranPrisma) => {
const player = await tranPrisma.playerData.create({
data: {
playerPID,
playerName,
playerAbilityATCK,
playerAbilityDEFEND,
playerAbilityMOBILITY,
},
});
});
// 성공시 전달 받은
return res.status(201).json({
message: `성공적으로 선수를 생성하였습니다. 선수ID : ${playerPID} 선수 이름 : ${playerName} 공격력 : ${playerAbilityATCK} 수비력 : ${playerAbilityDEFEND} 속력 : ${playerAbilityMOBILITY}
`,
});
} catch (err) {
next(err);
}
});
// 플레이어 뽑기 api
const gachaCosT = 100; // 1회 가챠 비용 (예시로 100 설정)
// 가챠 함수
const performGacha = async (userID) => {
try {
//트랜잭션 추가
const result = await prisma.$transaction(async (prisma) => {
// 유저 정보 조회
const user = await prisma.userData.findUnique({
where: { userID },
});
if (!user) {
throw new Error('User not found');
}
// 유저 캐시 확인
if (user.userCash < gachaCosT) {
throw new Error('Not enough cash for gacha');
}
// 캐시 차감
const updatedUser = await prisma.userData.update({
where: { userID },
data: {
userCash: user.userCash - gachaCosT, // 가챠 비용 차감
},
});
// playerData에서 랜덤한 선수 선택
const players = await prisma.playerData.findMany();
const randomPlayer = players[Math.floor(Math.random() * players.length)];
// 해당 유저의 playerRostersData에 선택한 선수 추가
const playerRoster = await prisma.playerRostersData.create({
data: {
userPID: user.userPID,
playerPID: randomPlayer.playerPID, // 각 선수마다 고유 ID
},
});
return {
updatedUser,
randomPlayer,
};
});
return {
message: `
🌟✨🌟✨🌟✨🌟
Congratulations! You got ${result.randomPlayer.playerName}!
🌟✨🌟✨🌟✨🌟
`,
player: result.randomPlayer,
};
} catch (error) {
return {
error: error.message,
};
}
};
// 선수 뽑기 API
router.post('/player/gacha', authenticateJWT, async (req, res) => {
const { userID } = req.user;
const result = await performGacha(userID);
if (result.error) {
return res.status(400).json({ error: result.error });
}
res.status(200).json({
message: result.message,
player: result.player,
});
});
//선수 강화 API
const upgradePlayer = async (req, res, next) => {
const maxUpgrade = 10; // 최대 강화 단계
try {
const { userPID } = req.user; // 인증된 유저 정보 가져오기
const { playerRostersPID, materials } = req.body; // 요청 바디에서 playerRostersPID와 materials 가져오기
// 유저 정보 조회
const user = await prisma.userData.findUnique({
where: { userPID },
});
if (!user) {
throw new Error('User not found');
}
// playerRostersPID를 통해 특정 선수 찾기
const existingPlayer = await prisma.playerRostersData.findUnique({
where: {
playerRostersPID, // playerRostersPID로 확인
},
});
if (!existingPlayer) {
throw new Error('Player does not exist');
}
// playerPID를 통해 playerData 조회
const playerStats = await prisma.playerData.findFirst({
where: {
playerPID: existingPlayer.playerPID, // existingPlayer에서 playerPID를 사용하여 조회
},
});
if (!playerStats) {
throw new Error('Player data not found');
}
// 강화 재료 확인
if (
!materials ||
!Array.isArray(materials) ||
materials.length < 1 ||
materials.length > 5
) {
return res
.status(400)
.json({ message: '강화에 최소 1명의 선수, 최대 5명이 필요합니다.' });
}
const materialCheck = await prisma.playerRostersData.findMany({
where: {
userPID,
playerRostersPID: { in: materials },
},
});
// // 중복된 playerPID 중 하나만 선택
// const uniqueMaterialCheck = [];
// const seen = new Set();
// materialCheck.forEach((item) => {
// if (!seen.has(item.playerRostersPID)) {
// uniqueMaterialCheck.push(item);
// seen.add(item.playerRostersPID);
// }
// }); >> PlayerID로 강화할 경우 필요
// 강화 재료가 유저 보유 선수인지 확인
if (materialCheck.length !== materials.length) {
return res
.status(400)
.json({ message: '강화 재료로 사용할 선수는 보유 선수가 아닙니다.' });
}
// 현재 강화 단계 확인
const currentUpgradeLevel = existingPlayer.playerEnchant || 0; // 현재 강화 단계
if (currentUpgradeLevel >= maxUpgrade) {
return res
.status(400)
.json({ message: '선수는 이미 최대 강화 단계에 도달했습니다.' });
}
//강화 확률 설정
let maxSuccessRate = Math.min(Math.max(materials.length * 20, 0), 100); //materials에 의한 확률을 최소 0, 최대 100으로 설정
switch (existingPlayer.playerEnchant) {
case 0:
maxSuccessRate -= 0;
break;
case 1:
maxSuccessRate -= 0;
break;
case 2:
maxSuccessRate -= 19;
break;
case 3:
maxSuccessRate -= 36;
break;
case 4:
maxSuccessRate -= 50;
break;
case 5:
maxSuccessRate -= 74;
break;
case 6:
maxSuccessRate -= 85;
break;
case 7:
maxSuccessRate -= 93;
break;
case 8:
maxSuccessRate -= 95;
break;
case 9:
maxSuccessRate -= 96;
break;
//추후 업그레이드 시 단계 추가
default:
break;
}
//강화 성공 시 선수 어빌리티 증가량 설정
let upgradeAbility = 0;
switch (existingPlayer.playerEnchant) {
case 0:
upgradeAbility += 1;
break;
case 1:
upgradeAbility += 1;
break;
case 2:
upgradeAbility += 1;
break;
case 3:
upgradeAbility += 2;
break;
case 4:
upgradeAbility += 2;
break;
case 5:
upgradeAbility += 3;
break;
case 6:
upgradeAbility += 3;
break;
case 7:
upgradeAbility += 4;
break;
case 8:
upgradeAbility += 5;
break;
case 9:
upgradeAbility += 5;
break;
default:
break;
}
const isSuccess = Math.random() * 100 <= maxSuccessRate;
// 강화 실패 처리
if (!isSuccess) {
return res.status(200).json({ message: '강화에 실패하였습니다.' });
}
// playerRostersData에서 해당 playerRostersPID만 업데이트
const result = await prisma.$transaction(async (prisma) => {
const updatedRosterPlayer = await prisma.playerRostersData.update({
where: {
playerRostersPID, // playerRostersPID로 해당 선수만 업데이트
},
data: {
playerEnchant: existingPlayer.playerEnchant + 1, // 강화 단계 증가
},
});
// 선수 강화
// const updatedPlayer = await prisma.playerData.update({
// where: { playerPID: existingPlayer.playerPID }, // 기존 playerPID를 사용하여 업데이트
// data: {
// playerAbilityATCK: playerStats.playerAbilityATCK + upgradeAbility, // 능력치 강화
// playerAbilityDEFEND: playerStats.playerAbilityDEFEND + upgradeAbility,
// playerAbilityMOBILITY: playerStats.playerAbilityMOBILITY + upgradeAbility,
// playerEnchant: existingPlayer.playerEnchant + 1, // 강화 단계 증가
// },
// }); >> 추후 RosterData에 능력치가 적용가능할 시 주석 해제
// 강화 재료 선수들 삭제
await prisma.playerRostersData.deleteMany({
where: {
userPID,
playerRostersPID: { in: materials },
},
});
// 트랜잭션 내에서 변경된 데이터를 반환
return updatedRosterPlayer; // 트랜잭션이 끝날 때 반환
});
return res.status(200).json({
message: `선수 강화가 완료되었습니다!`,
//updatedPlayer,
updatedRosterPlayer: result, //단일 객체로 바로 접근
});
} catch (err) {
next(err);
}
};
// 선수 강화 API 라우터 설정
router.put('/player/upgrade', authenticateJWT, upgradePlayer);
export default router;/* 기본 게임 기능 */
import express from 'express';
import { prisma } from '../uts/prisma/index.js';
import authMiddleware from '../middlewares/auth.middleware.js';
const router = express.Router();
//게임 매칭 완성
router.post('/game/match', authMiddleware, async (req, res, next) => {
const user_1 = req.user.userPID;
const user_1_score = req.user.userScore;
try {
//스코어 계산
const max_score = user_1_score + 500;
const min_score = user_1_score - 500;
//스코어에 어울리는 사람 찾기
const user_temp = await prisma.userData.findMany({
where: {
NOT: {
userPID: +user_1,
},
gameSessionPID: null,
userScore: {
gte: min_score,
lte: max_score,
},
},
take: 10,
include: {
playerSquadsData: {
include: {
playerEquipRostersData: true,
},
},
},
});
// let userArr = user_temp.filter(user => user.playerSquadsData[0].playerEquipRostersData.length >= 3);
// if(userArr.length === 0){
// // 매칭 실패
// return;
// }
// let random_index = Math.floor(Math.random() * userArr.length);
// let matchingUser = userArr[random_index];
let userArr = [];
for (let i = 0; i < user_temp.length; i++) {
if (user_temp[i].playerSquadsData[0].playerEquipRostersData.length < 3)
continue;
userArr.push(user_temp[i]);
// console.log(i);
// let random_index = Math.floor(Math.random() * user_temp.length);
// if (
// user_temp[random_index].playerSquadsData[0].playerEquipRostersData
// .length >= 3
// ) {
// user_2 = user_temp[random_index];
// return user_2;
// }
}
let random_index = Math.floor(Math.random() * userArr.length);
let user_2 = userArr[random_index];
//매칭 실패
console.log(user_2);
if (!user_2) {
throw { status: 404, message: ' 적합한 유저를 찾지 못했습니다. ' };
}
//성공시 트렌잭션으로 생성하고 플레이어 데이터에 pid 추가
const [game] = await prisma.$transaction(async (tx) => {
const game = await tx.gameSession.create({
data: {
userScore_1: 0,
userScore_2: 0,
sessionTurn: 0,
},
});
await tx.userData.update({
where: {
userPID: user_1,
},
data: {
gameSessionPID: game.gameSessionPID,
},
});
await tx.userData.update({
where: {
userPID: user_2.userPID,
},
data: {
gameSessionPID: game.gameSessionPID,
},
});
return [game];
});
if (!game) {
throw { status: 500, message: ' 매칭에 실패했습니다. ' };
}
res.status(200).json({ date: '적합한 상대와 매칭되었습니다.' });
} catch (err) {
next(err);
}
});
router.post('/game-start', authMiddleware, async (req, res, next) => {
try {
const { gameSessionPID } = req.user;
const user_data = await prisma.gameSession.findUnique({
where: {
gameSessionPID: gameSessionPID,
},
include: {
userData: {
include: {
playerSquadsData: {
include: {
playerEquipRostersData: true,
},
},
},
},
},
});
let user_1_player = [];
// 유저 데이터[0] 첫번째 유저의 스쿼드데이터에 플레이어 로스터 데이터의 갯수만큼 반복
for (
let i = 0;
i <
user_data.userData[0].playerSquadsData[0].playerEquipRostersData.length;
i++
) {
// 유저 데이터[0] 첫번째 유저의 스쿼드데이터에 플레이어 로스터 데이터의[i]번째의 playerRostPID의 보유선수 데이터 잘하면 여기 스킵 가능
const isPlayer_temp = await prisma.playerRostersData.findUnique({
where: {
playerRostersPID:
user_data.userData[0].playerSquadsData[0].playerEquipRostersData[i]
.playerRostersPID,
},
});
// 그 받아온 선수의 데이터를 선수데이터 db를 불러와서 선수의 실질적인 데이터 받아오기.
const player = await prisma.playerData.findFirst({
where: { playerPID: isPlayer_temp.playerPID },
});
//여기서 플레이어 선수 푸쉬 해주기
user_1_player.push({
player: player,
playerPosition:
user_data.userData[0].playerSquadsData[0].playerEquipRostersData[i]
.position,
});
}
//유저2선수
let user_2_player = [];
for (
let i = 0;
i <
user_data.userData[1].playerSquadsData[0].playerEquipRostersData.length;
i++
) {
const isPlayer_temp = await prisma.playerRostersData.findUnique({
where: {
playerRostersPID:
user_data.userData[1].playerSquadsData[0].playerEquipRostersData[i]
.playerRostersPID,
},
});
const player = await prisma.playerData.findFirst({
where: { playerPID: isPlayer_temp.playerPID },
});
user_2_player.push({
player: player,
playerPosition:
user_data.userData[1].playerSquadsData[0].playerEquipRostersData[i]
.position,
});
}
let user1Striker = user_1_player[0];
let user1Midfielder = user_1_player[1];
let user1Defender = user_1_player[2];
let user2Striker = user_2_player[0];
let user2Midfielder = user_2_player[1];
let user2Defender = user_2_player[2];
//스탯 정규화
//유저1
let user1STR =
user1Striker.player.playerAbilityATCK * 1.1 +
user1Striker.player.playerAbilityDEFEND * 0.8 +
user1Striker.player.playerAbilityMOBILITY * 0.7;
let user1MID =
user1Midfielder.player.playerAbilityATCK +
user1Midfielder.player.playerAbilityDEFEND * 0.8 +
user1Midfielder.player.playerAbilityMOBILITY;
let user1DEF =
user1Defender.player.playerAbilityATCK * 0.8 +
user1Defender.player.playerAbilityDEFEND * 1.2 +
user1Defender.player.playerAbilityMOBILITY * 0.7;
//유저2
let user2STR =
user2Striker.player.playerAbilityATCK * 1.1 +
user2Striker.player.playerAbilityDEFEND * 0.8 +
user2Striker.player.playerAbilityMOBILITY * 0.7;
let user2MID =
user2Midfielder.player.playerAbilityATCK +
user2Midfielder.player.playerAbilityDEFEND * 0.8 +
user2Midfielder.player.playerAbilityMOBILITY;
let user2DEF =
user2Defender.player.playerAbilityATCK * 0.8 +
user2Defender.player.playerAbilityDEFEND * 1.2 +
user2Defender.player.playerAbilityMOBILITY * 0.7;
//돌파가능 수치정하기
//유저1
let user1DribbleSTR = user1STR + user2STR;
let user1DribbleMID = user1STR + user2MID;
let user1DribbleDEF = user1STR + user2DEF;
let user1RS = Math.random() * user1DribbleSTR;
let user1RM = Math.random() * user1DribbleMID;
let user1RD = Math.random() * user1DribbleDEF;
//유저2
let user2DribbleSTR = user2STR + user1STR;
let user2DribbleMID = user2STR + user1MID;
let user2DribbleDEF = user2STR + user1DEF;
let user2RS = Math.random() * user2DribbleSTR;
let user2RM = Math.random() * user2DribbleMID;
let user2RD = Math.random() * user2DribbleDEF;
let resultMessage = '';
let gameSession = await prisma.gameSession.findFirst({
where: { gameSessionPID },
});
let currentTurn = gameSession ? gameSession.sessionTurn : 0;
let currentUser_1Score = gameSession ? gameSession.userScore_1 : 0;
let currentUser_2Score = gameSession ? gameSession.userScore_2 : 0;
if (currentTurn % 2 === 0) {
//유저1
resultMessage += `유저1 공격수의 드리블`;
// 공격수 돌파시도
if (user1RS < user1STR) {
resultMessage += `\n유저1의 ${user1Striker.player.playerName} 선수가 상대 ${user2Striker.player.playerName} 선수를 뚫고 지나갑니다. `;
// 미드필더 돌파시도
if (user1RM < user1STR) {
resultMessage += `\n유저1의 ${user1Striker.player.playerName} 선수가 상대 ${user2Midfielder.player.playerName} 선수를 뚫고 지나갑니다. `;
// 수비수 돌파시도
if (user1RD < user1STR) {
resultMessage += `\n유저1의 ${user1Striker.player.playerName} 선수가 상대 ${user2Defender.player.playerName} 선수를 뚫고 골을 넣었습니다!`;
currentUser_1Score++;
resultMessage += `\n현재스코어 ${currentUser_1Score} : ${currentUser_2Score}`;
} else {
resultMessage +=
'\n상대 수비수에게 막혔습니다. 공이 유저2 공격수에게 패스됩니다.';
currentTurn++;
}
} else {
resultMessage +=
'\n상대 미드필더에게 막혔습니다. 공이 유저2 공격수에게 패스됩니다.';
currentTurn++;
}
} else {
resultMessage +=
'\n상대 공격수에게 막혔습니다. 유저2 공격수가 드리블합니다.';
currentTurn++;
}
} else {
//유저2
resultMessage += `유저2 공격수의 드리블`;
// 공격수 시도
if (user2RS < user2STR) {
resultMessage += `\n유저2의 ${user2Striker.player.playerName} 선수가 상대 ${user1Striker.player.playerName} 선수를 뚫고 지나갑니다. `;
// 미드필더 시도
if (user2RM < user2STR) {
resultMessage += `\n유저2의 ${user2Striker.player.playerName} 선수가 상대 ${user1Midfielder.player.playerName} 선수를 뚫고 지나갑니다. `;
// 수비수 시도
if (user2RD < user2STR) {
resultMessage += `\n유저2의 ${user2Striker.player.playerName} 선수가 상대 ${user1Defender.player.playerName} 선수를 뚫고 골을 넣었습니다!`;
currentUser_2Score++;
resultMessage += `\n현재스코어 ${currentUser_1Score} : ${currentUser_2Score}`;
} else {
resultMessage +=
'\n상대 수비수가 막았습니다. 공을 유저1 공격수에게 패스합니다.';
currentTurn++;
}
} else {
resultMessage +=
'\n상대 미드필더가 막았습니다. 공을 유저1 공격수에게 패스합니다.';
currentTurn++;
}
} else {
resultMessage +=
'\n상대 공격수가 막았습니다. 유저1 공격수가 드리블합니다.';
currentTurn++;
}
}
await prisma.gameSession.update({
where: { gameSessionPID },
data: {
sessionTurn: currentTurn,
userScore_1: currentUser_1Score,
userScore_2: currentUser_2Score,
},
});
res.status(200).json({ message: resultMessage });
} catch (err) {
next(err);
}
});
//경기종료
router.delete('/game-end', authMiddleware, async (req, res, next) => {
try {
const { gameSessionPID } = req.user;
//유저데이터
const user_data = await prisma.gameSession.findUnique({
where: {
gameSessionPID: gameSessionPID,
},
include: {
userData: {
include: {
playerSquadsData: {
include: {
playerEquipRostersData: true,
},
},
},
},
},
});
const userPID_1 = user_data.userData[0].userPID;
const userPID_2 = user_data.userData[1].userPID;
//유저스코어
if (user_data.userScore_1 > user_data.userScore_2) {
await prisma.userData.update({
where: {
userPID: userPID_1,
},
data: {
userScore: user_data.userData[0].userScore + 10,
},
});
await prisma.userData.update({
where: {
userPID: userPID_2,
},
data: {
userScore: user_data.userData[1].userScore - 10,
},
});
}
if (user_data.userScore_1 < user_data.userScore_2) {
await prisma.userData.update({
where: {
userPID: userPID_2,
},
data: {
userScore: user_data.userData[1].userScore + 10,
},
});
await prisma.userData.update({
where: {
userPID: userPID_1,
},
data: {
userScore: user_data.userData[0].userScore - 10,
},
});
}
if (user_data.userScore_1 === user_data.userScore_2) {
await prisma.userData.update({
where: {
userPID: userPID_1,
},
data: {
userScore: user_data.userData[0].userScore,
},
});
await prisma.userData.update({
where: {
userPID: userPID_2,
},
data: {
userScore: user_data.userData[1].userScore,
},
});
}
await prisma.gameSessionHistory.create({
data: {
userPID_1: userPID_1,
userPID_2: userPID_2,
userScore_1: user_data.userScore_1,
userScore_2: user_data.userScore_2,
},
});
await prisma.gameSession.delete({
where: {
gameSessionPID: gameSessionPID,
},
});
res.status(200).json({
경기종료: `${user_data.userScore_1} : ${user_data.userScore_2}`,
});
} catch (err) {
next(err);
}
});
export default router;https://www.youtube.com/watch?v=JUIqi2PS8tk
영상 업로드 완료!