본캠프 3주차 (4)

import chalk from 'chalk';
import readlineSync from 'readline-sync';

class Player {
  constructor() {
    this.hp = 100; // 초기 체력
    this.maxHp = 100; // 최대 체력
    this.mp = 100;
    this.maxMp = 100;
    this.baseAttackPower = 10; // 초기 공격력은 10으로 설정
  }

  getAttackPower(stage) {
    const minAttackPower = Math.max(1, stage * 2 - 1); // 최소 공격력
    const maxAttackPower = stage === 1 ? 10 : stage * 5; // 1스테이지에서 최대 공격력 10
    return Math.floor(Math.random() * (maxAttackPower - minAttackPower + 1)) + minAttackPower; // 범위 내 랜덤 공격력 반환
  }

  attack(monster, stage) {
    const damage = this.getAttackPower(stage); // 스테이지에 따라 공격력 계산
    monster.hp -= damage; // 몬스터의 체력 감소
    return damage; // 공격한 피해량 반환
  }

  levelUp() {
    this.maxHp += 20; // 최대 체력 증가
    this.hp = this.maxHp; // 체력을 최대값으로 회복
  }
}

class Monster {
  constructor(stage) {
    this.hp = 100 + (stage - 1) * 20; // 스테이지에 따라 몬스터 체력 증가
  }

  getAttackPower(stage) {
    const minAttackPower = Math.max(1, stage * 2 - 1); // 최소 공격력
    const maxAttackPower = stage === 1 ? 10 : stage * 5; // 1스테이지에서 최대 공격력 10
    return Math.floor(Math.random() * (maxAttackPower - minAttackPower + 1)) + minAttackPower; // 범위 내 랜덤 공격력 반환
  }

  attack(player, stage) {
    const damage = this.getAttackPower(stage); // 스테이지에 따라 공격력 계산
    player.hp -= damage; // 플레이어의 체력 감소
    return damage; // 공격한 피해량 반환
  }
}

function displayStatus(stage, player, monster) {
  console.log(chalk.magentaBright(`\n=== Current Status ===`));
  console.log(
    chalk.cyanBright(`| Stage: ${stage} `) +
    chalk.blueBright(
      `| 플레이어 정보 (HP: ${player.hp}/${player.maxHp}, 기본 공격력: ${player.baseAttackPower})`,
    ) +
    chalk.redBright(
      `| 몬스터 정보 (HP: ${monster.hp}) |`,
    ),
  );
  console.log(chalk.magentaBright(`=====================\n`));
}

const battle = async (stage, player) => {
  const monster = new Monster(stage);
  let logs = [];

  while (player.hp > 0 && monster.hp > 0) {
    console.clear(); // 콘솔지우는 코드
    displayStatus(stage, player, monster);

    logs.forEach((log) => console.log(log));

    console.log(
      chalk.green(
        `\n1. 공격한다 2. 아무것도 하지않는다. 3. 도망간다. 4. 회피한다. 5. 마법을 사용한다. `,
      ),
    );
    const choice = readlineSync.question('당신의 선택은? ');

    logs.push(chalk.green(`${choice}를 선택하셨습니다.`));

    switch (choice) {
      case '1':
        const damage = player.attack(monster, stage); // 몬스터에게 공격
        logs.push(chalk.green(`플레이어가 몬스터에게 ${damage}의 피해를 주었습니다.`));
        console.log(`몬스터의 남은 체력: ${monster.hp}`);

        if (monster.hp > 0) {
          const monsterDamage = monster.attack(player, stage); // 플레이어에게 공격
          logs.push(chalk.red(`몬스터가 플레이어에게 ${monsterDamage}의 피해를 주었습니다.`));
          console.log(`플레이어의 남은 체력: ${player.hp}`);
        }
        break;

      case '2':
        logs.push(chalk.blue("플레이어가 아무것도 하지 않았습니다."));
        break;
        case '3':
        logs.push(chalk.blue("플레이어가 도망쳤습니다."));
        break;
        case '4':
        logs.push(chalk.blue("플레이어가 회피하였습니다."));
        break;
        case '5':
        logs.push(chalk.blue("플레이어가 마법을 사용하였습니다."));
        console.log(`플레이어의 남은 마법 사용 횟수: `);
        break;



      default:
        logs.push(chalk.yellow("잘못된 선택입니다. 다시 선택해주세요."));
        break;
    }
  }

  if (player.hp <= 0) {
    logs.push(chalk.red("플레이어가 패배했습니다."));
  } else if (monster.hp <= 0) {
    logs.push(chalk.green("몬스터를 처치했습니다!"));
  }

  return player.hp > 0; // 플레이어가 살아있으면 true 반환
};

export async function startGame() {
  console.clear();
  let stage = 1;
  let player = new Player();
  //let player2 = new Player(); // 플레이어는 한 명만 생성
  //console.log(player.hp,player2.hp);
  
  while (true) { // 무한 루프
    const isAlive = await battle(stage, player);

    if (!isAlive) {
      console.log(chalk.red("게임 오버!"));
      break; // 플레이어가 패배하면 게임 종료
    }

    player.levelUp(); // 스테이지가 증가할 때마다 플레이어의 최대 체력 증가 및 체력 회복
    stage++; // 스테이지 증가
  }

  console.log(chalk.green("게임이 종료되었습니다."));
}

프로젝트 하면서 망한것 같다는.. 생각이 들어서 새로 다시 해야할것같다..

 

기본기가 너무 약해서 다시 한번 정리하기

 

 다항연산자 : !(논리부정), ~(비트부정), + -(부호), ++ -- (증감연산자)

- 산순연산자 : *(곱하기), /(나누기), %(나머지연산자), +(더하기), -(빼기)

- 시프트연산자 : <<, >>, >>>

- 관계연산자 :  <, <=, >, >=, ==, !=

- 논리연산자 : 비트논리연산 &, ^, | 일반논리연산 &&, ||

- 조건연산자 : ?, :

- 대입연산자 : =, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |=

var과 let, const의 차이

1. Var : 중복 선언 가능
var name = 'javascript';
console.log(name); // javascript

var name = 'react';
console.log(name); // react
JavaScript
var 로 선언한 변수는 동일한 이름으로 여러 번 중복해서 선언이 가능함. 이와 같은 경우, 마지막에 할당된 값이 변수에 저장됨. 위의 예제를 보면 에러 없이 각기 다른 값이 출력되는 것을 볼 수 있음.
이는 필요할 때마다 변수를 유연하게 사용할 수 있다는 장점이 될 수도 있지만, 기존에 선언해둔 변수의 존재를 잊고 값을 재할당하는 등의 실수가 발생할 가능성이 큼. 특히 코드량이 많아졌을 때, 같은 이름의 변수명이 여러 번 선언되었다면 어디 부분에서 문제가 발생하는지 파악하기 힘들뿐더러 값이 바뀔 우려가 있음.
이를 보완하기 위해 ES6부터 추가된 변수 선언 방식이 let 과 const 임.
2-1. let : 중복 선언 불가능, 재할당 가능
let name = 'javascript';
console.log(name); // javascript

let name = 'react';
console.log(name);
// Uncaught SyntaxError: Identifier 'name' has already been declared

name = 'vue';
console.log(name); // vue
JavaScript
var 와 다르게 let 은 해당 변수가 이미 선언되었다는 에러 메시지가 출력됨. 이처럼 중복 선언이 불가능함.
name = 'vue' 와 같이 변수 선언 및 초기화 이후 반복해서 다른 값을 재할당 할 수는 있음.
2-2. const : 중복 선언 불가능, 재할당 불가능
const name = 'javascript';
console.log(name); // javascript

const name = 'react';
console.log(name);
// Uncaught SyntaxError: Identifier 'name' has already been declared

name = 'vue';
console.log(name);
// Uncaught TypeError: Assignment to constant variable
JavaScript
let 과 const 의 차이점은 immutable 의 여부임. let 은 변수에 다른 값을 재할당할 수 있지만, const 는 재할당 시 에러 메시지가 출력됨.
function func() {
	const list = ["A", "B", "C"]

    list = "D";
    console.log(list);
    // TypeError: Assignment to constant variable

    list.push("D");
    console.log(list); // ["A", "B", "C", "D"]
}
JavaScript
이처럼 const 는 constant(상수)를 뜻하기 때문에 한 번만 선언이 가능하며 값을 바꿀 수도 없음. 하지만 위 예제와 같이 배열과 오브젝트의 값을 변경하는 것은 가능함.
결과적으로 const 는 불변을 의미하는 것과 다르게, 값을 재할당하는 코드만 불가능하다고 볼 수 있음.

 

 

그리고 코드의 흐름을 보는게 가장 중요한데 코드가 어디서부터 실행되고 종료되는지 흐름을 파악하는게 가장 중요하다고 튜터님께 조언을 받았다. 계속해서 복습해보기..

감사합니다 튜터님 ㅜㅜ

 

<오늘의 정리>

Var : 중복 선언 가능

let : 중복 선언 불가능, 재할당 가능

const : 중복 선언 불가능, 재할당 불가능

코드의 흐름을 잘 파악하기

기본기 다지기