976 lines
46 KiB
C++
976 lines
46 KiB
C++
#pragma once
|
|
|
|
// 전반적인 게임 공식/상수들.
|
|
// 헤더에는 아무것도 include 하지 말것.
|
|
//
|
|
// percentage 는 0 ~ 1 사이의 값
|
|
//
|
|
// 2004/05/21 by Testors
|
|
|
|
#include <string>
|
|
|
|
#include <mmo/ArType.h>
|
|
#include <toolkit/XRandom.h>
|
|
#include <toolkit/c_fixed.h>
|
|
|
|
#include "GameType.h"
|
|
#include "StructGold.h"
|
|
|
|
|
|
namespace GameRule
|
|
{
|
|
|
|
extern bool bDirectInventoryLoot; // Whether drop should go directly in inventory instead of dropping on the ground
|
|
|
|
|
|
// AziaMafia GameRule
|
|
extern bool bItemDurabilitySwitch; // Credits to AziaMafia: Durability consumption switch
|
|
extern float fPlayerKillerBonusRate; // Credits to AziaMafia: Some stupid bullshit TODO
|
|
|
|
|
|
////////////////////////////////////////
|
|
|
|
const AR_UNIT VISIBLE_RANGE = 525;
|
|
const AR_UNIT RUNAWAY_RANGE = 175; // 도망형 몬스터의 도망 범위, 시야 거리를 3번에 나눠서 도망친다.
|
|
const int MAX_STATE_LEVEL = 65535; // 최대 지속효과 레벨
|
|
const float DEFAULT_HUMAN_SIZE = 1.0f; // 표준 생물체(인간)의 지름
|
|
const float DEFAULT_ATTACK_RANGE = 0.5f; // 기본 사거리 (50센티 정도)
|
|
const float MAX_ATTACK_RANGE = 0.84f;
|
|
const int DEFAULT_UNIT_SIZE = 12; // 1미터가 좌표상으로 얼마인지를 정의
|
|
const float SKILL_CAST_COST = 0.2f; // 스킬 시전시 20% 소비
|
|
const float SKILL_FIRE_COST = 0.8f; // 스킬 발사시 80% 소비
|
|
const float SKILL_CANCEL_RATE = 0.005f; // 캐스팅 캔슬이 일어나기 위한 데미지 비율 (MAXHP 대비)
|
|
const int MAX_LEVEL = 300; // 최대 레벨
|
|
const int MAX_JOB_DEPTH = 4; // 0차를 포함한 최대 직업 차수
|
|
const int MIN_TALENT_POINT_LEVEL = 148; // 특성포인트 획득 최소 레벨
|
|
const int MIN_TALENT_POINT_JOB_DEPTH = 3; // 특성포인트 획득 직업 차수
|
|
const int DEFAULT_TALENT_POINT = 2; // 마스터 클래스 전직 시 기본으로 주어지는 특성포인트
|
|
const __int64 MAX_OWNABLE_JP = 50000000000; // 보유 가능 최대 JP(500억)
|
|
|
|
const int NORMAL_SUMMON_MAX_LEVEL = 60; // 소환수 기본형 최대 레벨
|
|
const int GROWTH_SUMMON_MAX_LEVEL = 115; // 소환수 성장형 최대 레벨
|
|
const int EVOLVE_SUMMON_MAX_LEVEL = 300; // 소환수 진화형 최대 레벨
|
|
const int NORMAL_SUMMON_EVOLVE_LEVEL = 50;// 기본형 진화 레벨
|
|
const int GROWTH_SUMMON_EVOLVE_LEVEL = 100;// 성장형 진화 레벨
|
|
|
|
const int MAX_SUMMON_ENHANCE = 25; // 크리처 최대 강화
|
|
const int MAX_SUMMON_SKILL_TREE = 5; // 크리처가 가질 수 있는 최대 스킬트리 개수 (리소스)
|
|
|
|
const int FARM_MAX_LEVEL = 150; // 농장으로 키울 수 있는 최대 레벨
|
|
const int FARM_MAX_COUNT = 3; // 농장에 맡길 수 있는 최대 소환수
|
|
const int FARM_NON_CASH_MAX_COUNT = 1; // 일반 이용권으로 맡길 수 있는 최대 소환수의 수
|
|
|
|
const int ATTACK_RANGE_UNIT = 100; // 사정거리 단위. ( 내부적으로는 기획 DB 에서 ATTACK_RANGE_UNIT 를 곱한 값으로 처리된다 )
|
|
const AR_TIME TAMING_INTERVAL = 30000; // 테이밍 유지시간은 5분임
|
|
const StructGold MAX_GOLD_DROP( 100000000 ); // 최대 골드 드랍양
|
|
const int MAX_FIRST_ATTACK_BONUS_TIME = 6000; // 선공 보너스 적용 시간
|
|
|
|
const int SUB_TITLE_RATE_LIMIT = 5; // 부 호칭에서 사용 가능한 최대 등급
|
|
const int SUB_TITLE_COUNT = 5; // 부 호칭의 최대 수
|
|
const float SUB_TITLE_RATE = 0.1f; // 부 호칭의 성능 적용률
|
|
const AR_TIME TITLE_RESET_COOL_TIME = 30000; // 호칭을 해제하기 위한 쿨타임 5분
|
|
const int TITLE_CONDITION_MAX_GROUP = 10; // 호칭 조건의 최대 그룹 수
|
|
|
|
const unsigned int CHAT_YELL_RANGE = 40; // 500 / (150 / 12) 반경 500미터
|
|
const unsigned int CHAT_MAX_LENGTH = 255; // 최대 채팅 메시지 길이
|
|
|
|
const short DEFAULT_RUSH_SPEED = 140; // 러쉬일때 속도오~
|
|
const short DEFAULT_KNOCK_BACK_SPEED = 140; // 넉백일때 속도오~
|
|
|
|
const float UNMOUNT_PENALTY = 0.05f; // 말에서 떨어지면 체력 5% 감소
|
|
const int DEFAULT_UNMOUNT_PROBABILITY_ON_DAMAGE = 30;
|
|
const int DEFAULT_UNMOUNT_PROBABILITY_ON_CRITICAL_DAMAGE = 75;
|
|
|
|
const AR_TIME CASTING_DELAY_LOW = 20; // 캐스팅 딜레이
|
|
const AR_TIME CASTING_DELAY_MEDIUM = 50;
|
|
const AR_TIME CASTING_DELAY_HIGH = 100;
|
|
|
|
const AR_TIME DEFAULT_MP_DEC_TIME = 1000; // 오오라 시전시 MP 소진 시간
|
|
|
|
const AR_TIME BATTLE_WAITING_TIME = 1000; // 대련시 대기시간
|
|
const time_t COMPETE_ANSWER_WAITTING_DURATION = 60; // 대련 요청 후 자동 취소까지 응답 대기 시간(단위:초, 기본값:1분)
|
|
const time_t COMPETE_COUNTDOWN_DURATION = 10; // 대련 수락 후 시작까지 카운트다운 기간(단위:초, 기본값:10초)
|
|
const time_t COMPETE_DURATION = 900; // 대련 시작 후 타임아웃까지 기간(단위:초, 기본값:15분)
|
|
const AR_UNIT COMPETE_RING_SEMIDIAMETER = 500; // 대련 시작 지점으로부터 장외 반지름(단위:AR_UNIT, 기본값:500=약41.6m)
|
|
const c_fixed10 COMPETE_RESURRECT_HP_RECOVER_RATE = c_fixed10(0.1); //0.1 // 대련 사망 후 부활 시 회복 HP
|
|
|
|
const unsigned int MAX_TRADE_ITEM_COUNT = 10;
|
|
|
|
const int CASTING_CANCEL_LOW = 20; // 캐스팅 캔슬 확률 (%)
|
|
const int CASTING_CANCEL_MEDIUM = 50; // 캐스팅 캔슬 확률 (%)
|
|
const int CASTING_CANCEL_HIGH = 100; // 캐스팅 캔슬 확률 (%)
|
|
|
|
// 길드/연합/던전 재가입/재도전 기간 제한 관련
|
|
const int GUILD_REJOIN_BLOCK_DURATION_SEC = 86400 * 7;
|
|
const int ALLIANCE_REJOIN_BLOCK_DURATION_SEC = 86400 * 7;
|
|
const int GUILD_DUNGEON_RECHALLENGE_BLOCK_DURATION_SEC = 86400 * 7;
|
|
|
|
// 던전 입장 레벨 제한 관련
|
|
const int DUNGEON_ENTER_LEVEL_LIMIT_UPPER_RANGE = 10; // 던전 적정 레벨 기준 입장 가능 상위 레벨 범위
|
|
const int DUNGEON_ENTER_LEVEL_LIMIT_LOWER_RANGE = 40; // 던전 적정 레벨 기준 입장 가능 하위 레벨 범위
|
|
const int DUNGEON_RAID_REQUEST_LEVEL_LIMIT = 20; // 던전 레이드 신청 가능 레벨 제한(Ex. [던전레벨-20] 이상)
|
|
|
|
// 불카누스 던전
|
|
const int DUNGEON_VULCANUS_ID = 20000;
|
|
|
|
// 배틀 아레나 관련
|
|
// 연습 경기의 아레나 ID
|
|
const int BATTLE_ARENA_EXERCISE_GAME_ARENA_ID = 2501;
|
|
// 1개의 팀에 구성될 수 있는 최대 파티 수(16:16 경기에서 최대 2개의 파티가 1개의 팀이 됨)
|
|
const int BATTLE_ARENA_MAX_PARTY_COUNT_PER_TEAM = 2;
|
|
// 1개의 팀에 참여할 수 있는 최대 유저 수(값 부분 중 * 8 에서 8은 PartyManager::MAX_PARTY_MEMBER)
|
|
const int BATTLE_ARENA_MAX_MEMBER_COUNT_PER_TEAM = BATTLE_ARENA_MAX_PARTY_COUNT_PER_TEAM * 8;
|
|
// 1개의 방에 참여할 수 있는 최대 팀 수
|
|
const int BATTLE_ARENA_MAX_TEAM_COUNT = 2;
|
|
// 1개의 방에 참여할 수 있는 최대 유저 수(팀 구분 없이 모든 참가자)
|
|
const int BATTLE_ARENA_MAX_MEMBER_COUNT = BATTLE_ARENA_MAX_MEMBER_COUNT_PER_TEAM * BATTLE_ARENA_MAX_TEAM_COUNT;
|
|
// 빠른 입장으로 진행 중이던 경기에 참가하는 경우 카운트 다운 시간
|
|
const AR_TIME BATTLE_ARENA_QUICK_JOIN_COUNTDOWN = 1000;
|
|
// 경기 종료 후 모든 유저가 점수판을 보고 있는 상태에서 경기장에서 강제 이탈될 때까지의 시간
|
|
const AR_TIME BATTLE_ARENA_FORCE_QUIT_DELAY = 6000;
|
|
// 캐릭터당 최대 보유 가능 AP
|
|
const int BATTLE_ARENA_MAX_OWNABLE_POINT = 2000000000;
|
|
|
|
|
|
// 경기 진행 중 접속이 끊긴 유저가 다시 경기에 참여할 때까지 기다려주는 시간(기본값 3분)
|
|
extern AR_TIME nBattleArenaReconnectWaitDuration;
|
|
// MVP가 받는 승패 보상 비율(MVP 외의 유저는 1.0)
|
|
const c_fixed10 BATTLE_ARENA_MVP_REWARD_RATE = c_fixed10( 12000, true );
|
|
// 잠수 신고 쿨타임(기본값 3분)
|
|
const AR_TIME BATTLE_ARENA_ABSENCE_CHECK_COOLTIME = 18000;
|
|
// 잠수 신고 응답 제한 시간
|
|
const AR_TIME BATTLE_ARENA_ABSENCE_CHECK_ANSWER_LIMIT = 6000 + 500;
|
|
// 중첩 페널티 카운트로 인해 경기 결과 보상에 페널티를 받는 최소 페널티 카운트
|
|
const int BATTLE_ARENA_HALF_REWARD_PENALTY_COUNT = 4;
|
|
|
|
// GM 권한 관련
|
|
const int PERMISSION_FOR_PLAYER = 0; // 일반 플레이어
|
|
const int PERMISSION_FOR_D_GRADE = 50; // D 등급
|
|
const int PERMISSION_FOR_C_GRADE = 60; // C 등급
|
|
const int PERMISSION_FOR_B_GRADE = 70; // B 등급
|
|
const int PERMISSION_FOR_A_GRADE = 80; // A 등급
|
|
const int PERMISSION_FOR_GM = 100; // S 등급
|
|
|
|
// 피로도 시스템 관련
|
|
const int DEFAULT_MAX_STAMINA = 500000;
|
|
const AR_TIME STAMINA_UPDATE_TIME = 6000;
|
|
const int STAMINA_REGEN_IN_TENT = 120;
|
|
const int STAMINA_REGEN_ON_GOOD = 110;
|
|
const int STAMINA_REGEN_ON_AVERAGE = 100;
|
|
const int STAMINA_REGEN_IN_FIELD = 30;
|
|
const int BAD_CONDITION_LIMIT = 10000;
|
|
const int AVERAGE_CONDITION_LIMIT = 130000;
|
|
const float SECROUTE_STAMINA_REGEN_BONUS_RATE = 2.0f;
|
|
|
|
const AR_UNIT REFLECT_RANGE = 4 * DEFAULT_UNIT_SIZE;
|
|
|
|
const int CHANNEL_PRESERVE_TIME = 3600;
|
|
// 기공
|
|
const int ENERGY_MAX = 10;
|
|
const AR_TIME DEFAULT_ENERGY_UPKEEP_TIME = 180000; // 기공 유지 임시로 하루
|
|
|
|
// PK 관련
|
|
const AR_TIME PK_ON_TIME = 100; //1000
|
|
const AR_TIME PK_OFF_TIME = 100; //3000
|
|
|
|
const float ITEM_SELL_RATIO = 0.25f;
|
|
|
|
extern float fPlyMod;
|
|
extern float fEXPRate; // 경치 비율
|
|
|
|
extern float fGoldDropRate; // 돈 드랍 비율
|
|
extern float fItemDropRate; // 아이템 드랍 비율
|
|
extern float fCardDropRate;
|
|
extern float fPartyEXPRate[ 7 ]; // 파티 경치 보너스
|
|
extern int nPartyExpPenaltyLevel;
|
|
extern float fChaosDropRate; // 혼돈 드랍 비율
|
|
extern float fPVPDamageRateForPlayer; // PVP 시 적용 데미지 비율(가해자: 플레이어)
|
|
extern float fPVPDamageRateForSummon; // PVP 시 적용 데미지 비율(가해자: 소환수)
|
|
extern float fEVPDamageRate;
|
|
extern float fEVSDamageRate;
|
|
extern float fEVPBossDamageRate;
|
|
extern float fEVSBossDamageRate;
|
|
|
|
extern float fStaminaBonusRate; // 스테미너 보너스 혜택 비율(EXP/JP)
|
|
extern float fForgottenStaminaBonusRate;
|
|
extern float fStaminaRegenRate;
|
|
extern float fStaminaConsumeRate;
|
|
extern float fForgottenStaminaConsumeRate;
|
|
extern float fSuperSaveBonusRate; // 성장의 물약(구 슈퍼 세이버) 보너스 혜택 비율(EXP/JP)
|
|
extern int anSuperSaveLevelMinLimit[ 7 ]; // 성장의 물약(구 슈퍼 세이버) 제한 최소 레벨
|
|
extern int anSuperSaveLevelMaxLimit[ 7 ]; // 성장의 물약(구 슈퍼 세이버) 제한 최대 레벨
|
|
extern float fSummonStaminaSaveBonusRate[ 6 ]; // 소환수 스테미너 세이버(오곡 크래커) 보너스 혜택 비율(EXP)
|
|
|
|
extern float fAllyPCBangBonusRate; // 멤버쉽 PC방 혜택 비율(EXP/JP)
|
|
extern float fAllyPCBangChaosBonusRate; // 멤버쉽 PC방 혜택 비율(Lac)
|
|
extern float fPremiumPCBangBonusRate; // 더블 플러스 PC방 혜택 비율(EXP/JP)
|
|
extern float fPremiumPCBangChaosBonusRate; // 더블 플러스 PC방 혜택 비율(Lac)
|
|
extern float fPremiumPCBangGoldBonusDropRate; // 더블 플러스 PC방 혜택 비율(루피 드랍율, 기본값: 1.0)
|
|
extern float fPremiumPCBangItemBonusDropRate; // 더블 플러스 PC방 혜택 비율(아이템 드랍율, 기본값: 1.0)
|
|
extern float fPremiumPCBangChaosBonusDropRate; // 더블 플러스 PC방 혜택 비율(라크 드랍율, 기본값: 1.0)
|
|
extern bool bApplyStaminaBonusInPremiumPCBang; // 더블 플러스 PC방에서 스테미너 효과 적용 허용 여부
|
|
|
|
extern bool bUsePlayPoint; // 플레이 포인트 누적 여부
|
|
extern int nPlayPointAccumulateTerm; // 플레이 포인트 누적 간격
|
|
extern int nPlayPointAccumulateAmount; // 한 번의 플레이 포인트 누적시 누적될 포인트 량
|
|
extern float fPremiumPCBangPlayPointBonusRate; // 더블 플러스 PC방 혜택 비율(플레이 포인트)
|
|
|
|
extern bool bUseTimeBasedEventScript; // 스크립트 기반 시간제 이벤트 사용 여부
|
|
extern bool bUseTimeBasedEventDB; // DB SP 기반 시간제 이벤트 사용 여부
|
|
extern int nTermForTimeBasedEventScript; // 스크립트 기반 시간제 이벤트 발생 간격(분 단위)
|
|
extern int nTermForTimeBasedEventDB; // DB SP 기반 시간제 이벤트 발생 간격(분 단위)
|
|
|
|
extern int nMinSpeed;
|
|
extern int nItemHoldTime;
|
|
extern bool bIsNoCollisionCheck;
|
|
extern bool bSkipLoadingAttribute;
|
|
|
|
extern bool bMonsterWandering; // 몬스터 방황 여부.-_-
|
|
extern bool bMonsterCollisionToLine; // 반드시 시야 확인을 해야 하는 경우
|
|
extern bool bMonsterPathFinding; // 몬스터 길찾기 여부
|
|
extern bool bLogMonsterPathFinding; // 몬스터 길찾기 관련한 로직들의 발생 회수를 남긴다 (로깅 여부)
|
|
extern bool bLogSchedulingStatus; // 스케쥴링 관련 로직들의 발생 회수와 시간을 체크 (로깅 여부)
|
|
extern bool bIgnoreSkillCoolTime;// 스킬 쿨타임 무시 여부
|
|
extern bool bIsPKServer; // PK Server
|
|
extern bool bHardcore; // hardcore server
|
|
extern float fHardcoreExpRate; // 유저가 죽었을때 pk 서버 대비 경험치 감소율 ( 2.0이면 pk 서버보다 2배 더 경험치가 감소한다)
|
|
extern int nPKPenaltyLevel;
|
|
extern bool bDisablePKOn; // PK On 완전 금지
|
|
extern bool bIsAdultServer; // Adult Server
|
|
extern bool bRestrictSpeicialChar; // 로그인시 계정에 특수 문자 사용 제한 여부
|
|
extern std::string strAllowedSpecialChar; // 로그인시 계정에 허용할 특수 문자
|
|
extern bool bAutoOpen;
|
|
|
|
extern bool bDisableHuntaholic; // Huntaholic 가능 여부
|
|
|
|
extern bool bUseAutoJail; // 무저갱 사용 여부
|
|
|
|
extern int nSecuritySolutionType; // 보안 솔루션 종류(0: 사용 안 함, 1: 게임가드, 2: 핵실드, 3: X-Trap)
|
|
extern AR_TIME nPeriodOfSecuritySolutionCheck; // 보안 솔루션 클라/서버 체크 주기
|
|
extern AR_TIME nSecuritySolutionResponseTimeout; // 보안 솔루션 클라/서버 체크 요청 후 응답까지 제한 시간
|
|
extern std::string strSecuritySolutionExceptionalIP; // 보안 솔루션 클라/서버 체크 미적용 IP 주소 목록(;으로 구분)
|
|
|
|
extern bool bDisableDungeonRaidSiege;
|
|
extern bool bIsCashUsableServer;
|
|
extern bool bUseAccountAuthorityDB;
|
|
extern bool bCashItemDropable;
|
|
extern bool bUseAutoTrap;
|
|
extern bool bBroadcastEventItemPickup;
|
|
extern bool bUseGuildDonationPoint;
|
|
extern bool bRestrictBanWordForBooth;
|
|
extern int nMinBoothStartableLevel;
|
|
extern bool bLimitBoothOpenableLayerToZero; // 노점을 0번 레이어에서만 열 수 있도록 제한(수련자의 섬 사기 노점 악용 방지)
|
|
extern bool bDisableBuyBooth; // 구매 노점을 사용할 수 없도록 제한하는 기능
|
|
const unsigned int MAX_BOOTH_ITEM_COUNT = 8; // 노점에서 최대로 아이템을 등록할 수 있는 종류 수
|
|
extern bool bDisableBooth; // 노점 이용 불가 설정
|
|
extern bool bDisableTrade; // 거래 이용 불가 설정
|
|
|
|
extern bool bLimitAdvChatCount;
|
|
extern int nMinGlobalChatUsableLevel;
|
|
extern int nMaxStorageItemCount; // 창고 보관 가능 최대 아이템 수(DB 데이터 수)
|
|
extern int nMaxCharactersPerAccount; // 계정당 최대 캐릭터 수
|
|
|
|
extern bool bUseSecurityNo; // 보안 비밀번호 적용 여부
|
|
extern bool bUseSecurityNoForStorage; // 창고 이용 시 보안 비밀번호 적용 여부
|
|
extern bool bUseSecurityNoForDeletingCharacter; // 캐릭터 삭제 시 보안 비밀번호 적용 여부
|
|
extern bool bCheckStorageSecurityAlways; // 창고 이용 시 보안 비밀번호를 열때 마다 확인 여부
|
|
|
|
extern bool bLimitFieldLogout; // 블러디/데모니악 아닌 일반 캐릭터가 필드에서 로그아웃할 때 접속 종료 대기시간 적용 여부
|
|
extern AR_TIME nLogoutTimer; // 접속 종료 대기시간 기간
|
|
const AR_TIME LOGOUT_AVAILABLE_DURATION = 1000; // 접속 종료 대기시간 체크 완료 시점부터의 로그아웃 가능 기간(타이머 체크 완료 후 10초 경과시 로그아웃 처리 안 됨)
|
|
extern bool bForceUnregisterAccountOnKickFail; // 유저 접속 시도 시 킥 처리가 정상적으로 이루어지지 못할 경우 강제 계정 로그인 정보 리셋 여부
|
|
|
|
extern bool bForbiddenScriptInitialized; // 채팅 창을 통해 입력된 명령어 중 무시할 명령어 목록 초기화 여부
|
|
// 채팅 창을 통해 스크립트 명령어 입력 시 이 값이 false면 설정값을 다시 파싱함(onRunScript 참조)
|
|
extern std::string strForbiddenScript; // 채팅 창을 통해 입력된 명령어 중 무시할 명령어 목록(행 구분자 = ';', 행 내의 항목 구분자 = ',')
|
|
|
|
const unsigned int MAX_ACCOUNT_LEN = 60; // 유저 계정 최대 길이
|
|
extern bool bUseLoginLogoutDebug; // 로그인/로그아웃 로그 메시지 기록 기능 사용 여부(디버그용)
|
|
|
|
extern bool bLogVulcanusDungeon; // 불카누스 던전 로그 여부
|
|
|
|
extern bool bLimitGameTime; // 게임 중독 방지 시스템 적용 여부
|
|
extern int nMaxGameTimeLimitedAge; // 게임 중독 방지 시스템 - 게임 중독 방지 시스템 적용 최대 유저 나이
|
|
extern AR_TIME nMaxHealthyGameTime; // 게임 중독 방지 시스템 - 최대 건강 게임시간 제한
|
|
extern AR_TIME nMaxTiredGameTime; // 게임 중독 방지 시스템 - 최대 피로 게임시간 제한
|
|
|
|
extern int nEtherealDurabilityBaseConsumptionOnNormalAttack; // 에테리얼 내구도 평타 공격 시 기본 소모량
|
|
extern int nEtherealDurabilityBaseConsumptionOnSkillAttack; // 에테리얼 내구도 스킬 공격 시 기본 소모량(버프 포함)
|
|
extern int nEtherealDurabilityBaseConsumptionOnDamage; // 에테리얼 내구도 피격 시 기본 소모량
|
|
extern float nEtherealDurabilityConsumptionRate;
|
|
|
|
extern int nMaxLevel; // 최고 레벨
|
|
extern int nMaxCreatureLevel; // 크리처 최대 레벨
|
|
|
|
extern float fMonsterRegen;
|
|
extern float fMonsterRegenBoss;
|
|
|
|
extern float fSummonExpLimit;
|
|
extern int nSummonExpPenaltyLevel;
|
|
|
|
extern float fKillImmoralPercentage;
|
|
extern float fKilledDrop;
|
|
extern float fKilledExpPercentage;
|
|
|
|
extern int nCrimeState;
|
|
extern int nCrimeParty;
|
|
|
|
extern int nBossEffect;
|
|
|
|
extern int nException_AR;
|
|
extern int nException_921;
|
|
extern float fException_31109;
|
|
extern float fException_31309;
|
|
|
|
extern int bIsLakGuard;
|
|
|
|
extern int nItemExpertCube;
|
|
extern int nItemExpertGrade;
|
|
|
|
|
|
extern std::string strLogRequiredStateList; // 소멸 시 로그를 남겨야 하는 지속효과 ID 목록
|
|
extern std::string strLogRequiredItemList; // 기간 만료 시 로그를 남겨야 하는 아이템 ID 목록
|
|
|
|
const c_fixed10 MORAL_LIMIT = c_fixed10( 100 ); // 블러디 캐릭터가 되기 위한 IP 수치(천벌 1Lv)
|
|
const c_fixed10 SEMI_CRIME_LIMIT = c_fixed10( 500 ); // 천벌 2Lv을 받기위한 IP 수치
|
|
const c_fixed10 CRIME_LIMIT = c_fixed10( 1000 ); // 데모니악 캐릭터가 되기 위한 IP 수치(천벌 3Lv)
|
|
|
|
// 기부 관련
|
|
const char MAX_DONATE_ITEM_COUNT = 9; // 기부 시스템에서 최대 한 번에 기부할 수 있는 서로 다른 종류의 아이템 수
|
|
const StructGold MIN_DONATE_GOLD = StructGold( 0 );
|
|
//const int MIN_DONATE_JP = 20000;
|
|
const __int64 DONATE_GOLD_UNIT_COUNT = 10000;
|
|
//const c_fixed10 DONATE_GOLD_PER_JP = c_fixed10( 0.5 );
|
|
|
|
const AR_TIME ITEM_ARRANGE_COOL_TIME = 3000; // 인벤토리/창고 정렬 기능 쿨타임
|
|
|
|
const float BOW_AIMING_TIME_RATIO = 0.8f;
|
|
const AR_TIME DEFAULT_HEAVY_BOW_INTERVAL = 50; // 기본 활 휴지기
|
|
const AR_TIME DEFAULT_LIGHT_BOW_INTERVAL = 250; // 기본 활 휴지기
|
|
|
|
const AR_TIME DEFAULT_DOUBLE_SUMMON_TIME = 1000; // 1000 Temps d'invocation simultanée de base
|
|
const AR_TIME BIND_SUMMON_UPDATE_TIME = 1000; // Heure de mise à jour des créatures non invoquées.
|
|
|
|
const AR_UNIT CHANGE_LOCATION_ERROR_RANGE = 10 * DEFAULT_UNIT_SIZE; // 위치 바꿀 때 오차범위
|
|
const AR_UNIT TACTICAL_POSITION_REBIRTH_ERROR = 4 * DEFAULT_UNIT_SIZE; // 던전 시즈에서 전략 거점 부활시 좌표 오차 거리
|
|
|
|
const float MONSTER_PRESPAWN_RATE = 0.5f; // 몬스터 월드에 미리 리젠해놓는 몬스터 비율
|
|
#ifdef _DEBUG
|
|
const AR_TIME MONSTER_RESPAWN_DECREASE_INTERVAL = 6000; // 리젠된 몬스터 수 최소로 줄이는 시간 간격(디버깅 모드: 1분)
|
|
#else
|
|
const AR_TIME MONSTER_RESPAWN_DECREASE_INTERVAL = 18000; // 리젠된 몬스터 수 최소로 줄이는 시간 간격(릴리즈 모드: 3분)
|
|
#endif
|
|
|
|
const AR_UNIT PARTY_ITEM_SHARE_RANGE = 400; // 파티 아이템 분배 방식에 영향을 받는 유저 판별 최대 거리
|
|
|
|
const AR_UNIT AGGRESIVE_MONSTER_REACTION_RANGE = 10 * DEFAULT_UNIT_SIZE; // 선공몹 어그로 범위
|
|
const AR_UNIT MONSTER_TRACKING_RANGE_BY_TIME = 30 * DEFAULT_UNIT_SIZE; // 추적 범위 ( 이 이상 거리가 멀어지면 다른 타겟을 찾아갑니다~ )
|
|
const AR_UNIT MONSTER_TRACKING_RANGE = 50 * DEFAULT_UNIT_SIZE; // 추적 범위 ( 이 이상 거리가 멀어지면 다른 타겟을 찾아갑니다~ )
|
|
const AR_UNIT MONSTER_COME_BACK_HOME_RANGE = 150 * DEFAULT_UNIT_SIZE; // 집-ㅅ-에서 너무 멀리 떨어져나와, 향수를 느껴 집으로 다시 돌아가게 되는 거리.
|
|
|
|
const AR_UNIT SUMMON_FOLLOWING_FIRST_SPEED_UP_RANGE = 3 * DEFAULT_UNIT_SIZE; // ¼Òȯ¼ö°¡ ÁÖÀÎ À̵¿¼ÓµµÀÇ 1Â÷ ¹èÀ²·Î µû¶ó°¡´Â °Å¸®
|
|
const float SUMMON_FOLLOWING_FIRST_SPEED_UP_RATE = 3.0f; // 1.2f;
|
|
const AR_UNIT SUMMON_FOLLOWING_SECOND_SPEED_UP_RANGE = 40 * DEFAULT_UNIT_SIZE; // ¼Òȯ¼ö°¡ ÁÖÀÎ À̵¿¼ÓµµÀÇ 2Â÷ ¹èÀ²·Î µû¶ó°¡´Â °Å¸®
|
|
const float SUMMON_FOLLOWING_SECOND_SPEED_UP_RATE = 7.0f; // 1.5f;
|
|
const AR_UNIT SUMMON_FOLLOWING_LIMIT_RANGE = 150 * DEFAULT_UNIT_SIZE; // ¼Òȯ¼ö°¡ ÁÖÀÎ µû¶ó°¡±â¸¦ ¸ØÃß´Â °Å¸®
|
|
|
|
const float PET_FOLLOWING_COMMON_SPEED_RATE = 3.0f;// 1.1f; // 펫의 평소 이동속도의 주인 이동속도에 대한 배
|
|
const AR_UNIT PET_FOLLOWING_HURRY_SPPED_RANGE = 10 * DEFAULT_UNIT_SIZE; // 펫의 더 빠른 속도로 주인을 따라가는 거리
|
|
const float PET_FOLLOWING_HURRY_SPEED_RATE = 10.0f; //2.0f // 펫이 주인과 멀어져서 빨리 따라갈 때 주인 이동속도에 대한 비율
|
|
const AR_UNIT PET_FOLLOWING_LIMIT_RANGE = 150 * DEFAULT_UNIT_SIZE; // 펫이 주인 따라가기를 멈추는 거리
|
|
|
|
const int PET_SHOVELING_SUCCESS_PERCENT_NORMAL = 30; // 일반 펫이 삽질에 성공할 확률
|
|
const int PET_SHOVELING_SUCCESS_PERCENT_RARE = 50; // 레어 펫이 삽질에 성공할 확률
|
|
|
|
enum PET_SHOVELING_REWARD_TYPE
|
|
{
|
|
PET_SHOVELING_REWARD_UNKNOWN = -1,
|
|
|
|
PET_SHOVELING_REWARD_ITEM = 0,
|
|
PET_SHOVELING_REWARD_STATE = 1,
|
|
PET_SHOVELING_REWARD_MONSTER = 2,
|
|
|
|
PET_SHOVELING_REWARD_TYPE_COUNT // 삽질 성공 시 나올 보상 종류 수
|
|
};
|
|
const int PET_SHOVELING_REWARD_TYPE_PERCENT[ PET_SHOVELING_REWARD_TYPE_COUNT ] = { 85, 5, 10 }; // 삽질 성공 시 나올 보상 종류에 따른 확률(아이템, 지속효과, 몬스터 순)
|
|
const AR_TIME PET_SHOVELING_REWARD_STATE_DURATION = 120000; // 삽질 성공 시 보상으로 걸리는 지속효과의 기간
|
|
const int PET_SHOVELING_REWARD_MONSTER_PET_PERCENT = 1; // 삽질 성공 시 보상으로 몹이 리젠될 때 레어 펫이 일반 펫용 몬스터를 소환할 확률
|
|
|
|
const AR_UNIT PET_SHOVELING_LIMIT_DISTANCE_FROM_MASTER = 10 * DEFAULT_UNIT_SIZE; // 삽질 중 주인과의 한계 거리
|
|
const AR_UNIT PET_SHOVELING_LIMIT_ROAMING_DISTANCE = 8 * DEFAULT_UNIT_SIZE; // 삽질 중 주인과의 한계 거리
|
|
|
|
const AR_TIME PET_SHOVELING_SEARCH_DURATION = 200; // 삽질 - 주변 탐색 기간
|
|
const AR_TIME PET_SHOVELING_APPROACH_DURATION = 300; // 삽질 - 이동 기간
|
|
const int PET_SHOVELING_APPROACH_SPEED = 75;//75; // 삽질 이동 기간 중 이동 속도
|
|
|
|
const int MONSTER_FIND_ATTACK_POS_RATIO = 5; // 공격 중 다른 몬스터와 겹칠때 적절한 위치를 찾을 확률
|
|
|
|
const float ALLOWED_POSITION_TIME_SYNC_MODIFIER = 6.0f;
|
|
const AR_UNIT ALLOWED_POSITION_SYNC_RANGE = 10 * DEFAULT_UNIT_SIZE;
|
|
const int ALLOWED_NON_REGION_UPDATE_COUNT = 5;
|
|
|
|
// PC 방 보너스 관련
|
|
const char PCBANG_NO_BONUS = 0;
|
|
const char PCBANG_ALLY_BONUS = 1;
|
|
const char PCBANG_PREMIUM_BONUS = 2;
|
|
|
|
// 기부 관련
|
|
const int DONATION_MAX_REWARD_ITEM_TYPE = 4;
|
|
const c_fixed10 DONATION_POINT_FOR_REWARD_ITEM[DONATION_MAX_REWARD_ITEM_TYPE] = { 2000, 10000, 20000, 30000 }; // 기부 보상을 받기 위한 등급별 모럴 포인트
|
|
const int DONATION_REWARD_ITEM_CODE[DONATION_MAX_REWARD_ITEM_TYPE] = { 3620026, 3620025, 3620024, 3620023 }; // 기부 보상으로 받게되는 등급별 아이템 코드
|
|
|
|
const char MAX_MORAL_GRADE = 20;
|
|
|
|
// 에테리얼 내구도 관련
|
|
const int MAX_ETHEREAL_DURABILITY = 2000000000; // 최대 에테리얼 내구도 충전 가능량
|
|
const int MAX_ETHEREAL_STONE_DURABILITY = 1000000000; // 최대 에테리얼 스톤 충전 가능량
|
|
const c_fixed10 ETHEREAL_DURABILITY_ENVIRONMENTAL_CONSUME_RATE_ON_PVP = c_fixed10( 0.05 );
|
|
const int ETHEREAL_DURABILITY_ENVIRONMENTAL_CONSUME_RATE_ON_PK = 2;
|
|
|
|
// 소울스톤 관련
|
|
const int ENDURANCE_REDUCE_ON_ATTACK = 0; // 500
|
|
const int ENDURANCE_REDUCE_ON_SKILL = 0; // 1000
|
|
const int ENDURANCE_REDUCE_ON_DAMAGE = 0; // 75
|
|
const double COST_CHAOS_PER_PEPAIR_POINT = 1.2; // 영혼력 1 충전시 소모 라크량
|
|
|
|
|
|
|
|
// 소지금 한도 관련
|
|
const StructGold MAX_GOLD_FOR_INVENTORY(999999999999); // 인벤토리 소지금 한도 100억 => 2014/02/26 러시아 퍼블리셔의 건의로 전 서버 소지금 한도 1000억 루피로 증가
|
|
const StructGold MAX_GOLD_FOR_STORAGE(999999999999); // 창고 소지금 한도 1000억 루피
|
|
|
|
// AziaMafia HDV Taxe Time
|
|
/*
|
|
const int AUCTION_ITEM_KEEP_DURATION = 60 * 60 * 24 * 15; // 경매 아이템 보관 기간(15일)
|
|
const c_fixed10 AUCTION_MIN_BIDDING_PRICE_RATE = c_fixed10( 1.01 ); // 경매 입찰시 최저 입찰가 비율
|
|
const c_fixed10 AUCTION_MIN_INSTANT_PURCHASE_PRICE_RATE = c_fixed10( 1.00 ); // 경매 등록시 최저 즉구가 비율
|
|
const c_fixed10 AUCTION_SELL_TAX_RATE = c_fixed10( 0.03 ); // 경매 물품 판매시 판매 가격에 대한 수수료율
|
|
const time_t AUCTION_DURATION_SHORTTERM = 60 * 60 * 6; // 경매 단기 등록 기간(6시간)
|
|
const time_t AUCTION_DURATION_MIDTERM = 60 * 60 * 24; // 경매 중기 등록 기간(24시간)
|
|
const time_t AUCTION_DURATION_LONGTERM = 60 * 60 * 72; // 경매 장기 등록 기간(72시간)
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_SHORTTERM = c_fixed10( 0.03 ); // 경매 단기 등록 수수료율
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_MIDTERM = c_fixed10( 0.04 ); // 경매 중기 등록 수수료율
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_LONGTERM = c_fixed10( 0.05 ); // 경매 장기 등록 수수료율
|
|
*/
|
|
const int AUCTION_ITEM_KEEP_DURATION = 60 * 60 * 24 * 60 ; //30jours
|
|
const c_fixed10 AUCTION_MIN_BIDDING_PRICE_RATE = c_fixed10(1.01);
|
|
const c_fixed10 AUCTION_MIN_INSTANT_PURCHASE_PRICE_RATE = c_fixed10(1.0);
|
|
const c_fixed10 AUCTION_SELL_TAX_RATE = c_fixed10(0.00);
|
|
|
|
// Fraun auction modifications 8/19/2025
|
|
const time_t AUCTION_DURATION_SHORTTERM = 60 * 60 * 24;
|
|
const time_t AUCTION_DURATION_MIDTERM = 60 * 60 * 24 * 7;
|
|
const time_t AUCTION_DURATION_LONGTERM = 60 * 60 * 24 * 15;
|
|
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_SHORTTERM = c_fixed10(0.03); // 경매 단기 등록 수수료율
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_MIDTERM = c_fixed10(0.04); // 경매 중기 등록 수수료율
|
|
const c_fixed10 AUCTION_REGISTER_TAX_RATE_LONGTERM = c_fixed10(0.05); // 경매 장기 등록 수수료율
|
|
|
|
|
|
extern AR_TIME nAuctionSearchRequestMinInterval; // 경매 검색 반복 가능 최단 시간 간격(1/100 초 단위)
|
|
extern AR_TIME nAuctionProcessRequestMinInterval; // 경매 일반 동작 반복 가능 최단 시간 간격(검색 제외 모두 적용)
|
|
|
|
const int AUCTION_INFO_COUNT_PER_PAGE_FOR_SEARCHED = 40; // 클라이언트 경매장 UI 중 물품 검색 창에서 한 페이지당 표시되는 경매 데이터 개수(화면당 8개 동시 표시)
|
|
const int AUCTION_INFO_COUNT_PER_PAGE_FOR_REGISTERED = 40; // 클라이언트 경매장 UI 중 경매 등록 창에서 한 페이지당 표시되는 경매 데이터 개수(화면당 9개 동시 표시)
|
|
const int AUCTION_INFO_COUNT_PER_PAGE_FOR_BIDDED = 40; // 클라이언트 경매장 UI 중 입찰 목록창에서 한 페이지당 표시되는 경매 데이터 개수(화면당 9개 동시 표시)
|
|
const int AUCTION_INFO_COUNT_PER_PAGE_FOR_ITEM_KEEPING = 40; // 클라이언트 경매장 UI 중 보관함 창에서 한 페이지당 표시되는 아이템 보관 데이터 개수(화면당 9개 동시 표시)
|
|
|
|
#ifdef _DEBUG
|
|
const int AUCTION_MAX_BIDDER_LIST_LENGTH = 3; // 특정 경매에 대해서 보관할 지난 입찰자들 수(vBidderUID 벡터의 길이를 제한)
|
|
#else
|
|
const int AUCTION_MAX_BIDDER_LIST_LENGTH = 250; // 특정 경매에 대해서 보관할 지난 입찰자들 수(vBidderUID 벡터의 길이를 제한)
|
|
#endif
|
|
|
|
// 로밍 관련
|
|
const AR_UNIT ROAMING_MAX_DISTANCE_FROM_OWN_POSITION = static_cast< AR_UNIT >( 0.2f * DEFAULT_UNIT_SIZE ); // 로밍시 몹/NPC가 자신의 원래 위치에 있다고 판단하는 최대 거리
|
|
const float ROAMING_ROATING_MOVE_SPEED_RATE = 1.5f; // 로밍 중 대형 방향 전환 시 이동 속도
|
|
|
|
// 헌터홀릭 관련
|
|
const size_t HUNTAHOLIC_MAX_INSTANCE_COUNT = 200; // 헌터홀릭 인스턴스 던전 생성 최대 개수
|
|
const size_t HUNTAHOLIC_MAX_INSTANCE_COUNT_PER_PAGE = 16; // 헌터홀릭 인스턴스 던전 목록 UI에서 한 페이지에 보여지는 최대 개수
|
|
const int HUNTAHOLIC_MAX_INSTANCE_NAME_LENGTH = 30; // 헌터홀릭 인스턴스 던전의 이름 최대 길이(30 바이트)
|
|
const int HUNTAHOLIC_MAX_INSTANCE_PASSWORD_LENGTH = 16; // 헌터홀릭 인스턴스 던전의 비밀번호 최대 길이(16 바이트)
|
|
const int HUNTAHOLIC_MAX_OWNABLE_POINT = 2000000000; // 헌터홀릭 포인트 최대 보유 가능량(20억)
|
|
const int HUNTAHOLIC_SCORE_FOR_LV1_MONSTER = 1; // 헌터홀릭 1등급 몬스터가 주는 점수
|
|
const int HUNTAHOLIC_SCORE_FOR_LV2_MONSTER = 5; // 헌터홀릭 2등급 몬스터가 주는 점수
|
|
const int HUNTAHOLIC_SCORE_FOR_LV3_MONSTER = 10; // 헌터홀릭 3등급 몬스터가 주는 점수
|
|
const int HUNTAHOLIC_SCORE_FOR_BOSS_MONSTER = 150; // 헌터홀릭 보스 몬스터가 주는 점수
|
|
const unsigned char HUNTAHOLIC_UNUSABLE_LOBBY_LAYER = 0xFF; // 헌터홀릭 로비 레이어 중 사용 불가 레이어(오류 코드용)
|
|
const AR_TIME HUNTAHOLIC_DUNGEON_BEGIN_COUNTDOWN_TIME = 1000; // 헌터홀릭 사냥 시작 전 카운트 다운 기간(시작 버튼 클릭 시점으로부터 value 만큼)
|
|
const AR_TIME HUNTAHOLIC_DUNGEON_END_NOTICE_TIME = 6000; // 헌터홀릭 사냥 종료 알림 공지 시각(종료 시점으로부터 value 전)
|
|
const AR_TIME HUNTAHOLIC_QUITTING_PENALTY_DEBUFF_TIME = 6000; // 헌터홀릭 사냥 중 직접 중도 포기하는 경우 주어지는 페널티 디버프(이속 저하)의 기간
|
|
const int HUNTAHOLIC_ENTERANCE_COUNT_PER_DAY = 12; // 헌터홀릭 사냥 도전 제한 횟수
|
|
|
|
// 데스매치 관련
|
|
const AR_TIME BEGINNING_TIME_IN_DEATHMATCH = 2000;
|
|
const float HEALING_RATE_ON_KILL_IN_DEATHMATCH = 0.3f;
|
|
|
|
// 채팅 금지 관련
|
|
const int MAX_BLOCK_TIME = 144000; // 채팅 금지 최대 제한 시간(100일, 분 단위)
|
|
|
|
// 캐쉬 관련
|
|
const int MAX_SECROUTE_REMAIN_TIME = 200 * 86400; // 최대 시크루트 프리패스 잔여 기간(보이기에만 제한)
|
|
|
|
// 아이템 파괴 관련
|
|
const char MAX_ERASE_ITEM_COUNT = 25; // 한 번에 파괴할 수 있는 서로 다른 종류의 아이템 수
|
|
|
|
// 아이템 분해 관련
|
|
const char MAX_DECOMPOSE_ITEM_COUNT = 16; // 한 번에 분해할 수 있는 서로 다른 종류의 아이템 수
|
|
const char MAX_DECOMPOSE_COUNT_PER_ITEM = 100; // 한 번에 분해할 수 있는 한 종류의 중첩 아이템 개수
|
|
|
|
// Monster Creature 관련
|
|
const char MAX_MONSTER_CREATURE_COUNT = 10;
|
|
const char MAX_RANDOM_SKILL_COUNT = 15;
|
|
const char USE_SKILL_ALL_OBJECT = 99;
|
|
|
|
// 농장 관련
|
|
extern int nFarmNormalSummonEXP; // 소환수 기본형의 농장 시간당 경험치
|
|
extern int nFarmGrowthSummonEXP; // 소환수 성장형의 농장 시간당 경험치
|
|
extern int nFarmEvolveSummonEXP; // 소환수 진화형의 농장 시간당 경험치
|
|
|
|
extern int nPremiumFarmNormalSummonEXP; // 소환수 기본형의 농장 시간당 경험치 (프리미엄 티켓 이용)
|
|
extern int nPremiumFarmGrowthSummonEXP; // 소환수 기본형의 농장 시간당 경험치 (프리미엄 티켓 이용)
|
|
extern int nPremiumFarmEvolveSummonEXP; // 소환수 기본형의 농장 시간당 경험치 (프리미엄 티켓 이용)
|
|
|
|
extern int nGuildBuffMinute;
|
|
extern int nGuildDonateGold;
|
|
|
|
// Account authority-related (including secroute) (Hidden Village)
|
|
enum AccountAuthority
|
|
{
|
|
AUTHORITY_SECROUTE = 910000,
|
|
};
|
|
|
|
int GetSummonEXPLimit( int level );
|
|
int GetPlayerEXPLimit( int level );
|
|
float GetSummonLevelPenalty( int master_level, int summon_level );
|
|
float GetSummonStatPenalty( int master_level, int summon_level );
|
|
|
|
void RegisterBlockAccount( const char * szAccount );
|
|
void DeleteFromBlockAccount( const char * szAccount );
|
|
bool IsBlockedAccount( const char * szAccount );
|
|
|
|
// 먹자 방지 시간
|
|
inline AR_TIME GetPickupOrderTime( int idx ) { return 3000 + idx * 1000; }
|
|
// 시체 유지 시간
|
|
inline int GetCorpseHoldTime() { return 1200; } // 10초
|
|
|
|
// 소환수 사망 후 역소환 대기 시간
|
|
inline int GetDeadSummonHoldTime() { return 12000; } // 60
|
|
|
|
inline const c_fixed10 GetCritical( const c_fixed10 & luck ) { return luck * 0.2 + 3; }
|
|
|
|
inline const c_fixed10 GetItemChance( const c_fixed10 & luck ) { return luck * 0.2; }
|
|
|
|
// 공격력 (2010-05-07 리뉴얼 적용)
|
|
inline const c_fixed10 GetBowAttackPoint( const c_fixed10 & agility, const c_fixed10 & dexterity, const float level, const c_fixed10 & fCM )
|
|
{ return ( agility * 1.2 + dexterity * 2.2 ) * fCM + level; }
|
|
inline const c_fixed10 GetAttackPoint( const c_fixed10 & strength, const float level, const c_fixed10 & fCM )
|
|
{ return strength * 2.8 * fCM + level; }
|
|
|
|
// 마법 공격력 (2007-03-24 리뉴얼 적용)
|
|
inline const c_fixed10 GetMagicPoint( const c_fixed10 & intelligence, const float level, const c_fixed10 & fCM )
|
|
{ return intelligence * 2 * fCM + level; }
|
|
|
|
// 방어력 (2010-05-07 리뉴얼 적용)
|
|
inline const c_fixed10 GetDefence( const float level, const c_fixed10 & vital, const c_fixed10 & fCM )
|
|
{ return vital * 1.6 * fCM + level; }
|
|
|
|
// 마법 방어력 (2007-03-24 리뉴얼 적용)
|
|
inline const c_fixed10 GetMagicDefence( const float level, const c_fixed10 & men, const c_fixed10 & fCM )
|
|
{ return men * 2 * fCM + level; }
|
|
|
|
// 명중수치
|
|
inline const c_fixed10 GetAccuracy( const c_fixed10 & dexterity, const float level, const c_fixed10 & fCM )
|
|
{ return dexterity * 0.5 * fCM + level; }
|
|
|
|
// 마법명중수치
|
|
inline const c_fixed10 GetMagicAccuracy( const c_fixed10 & mental, const c_fixed10 & dexterity, const float level, const c_fixed10 & fCM )
|
|
{ return ( ( mental * 0.4 ) + ( dexterity * 0.1 ) ) * fCM + level; }
|
|
|
|
// 마법저항수치 (2007-03-24 리뉴얼 적용)
|
|
inline const c_fixed10 GetMagicAvoid( const c_fixed10 & mental, const float level, const c_fixed10 & fCM )
|
|
{ return ( mental * 0.5 ) * fCM + level; }
|
|
|
|
// 회피수치 (2007-03-24 리뉴얼 적용)
|
|
inline const c_fixed10 GetAvoid( const c_fixed10 & agility, const float level, const c_fixed10 & fCM )
|
|
{ return ( agility * 0.5 ) * fCM + level; }
|
|
|
|
// 시전속도 (2007-03-24 리뉴얼 적용)
|
|
inline const c_fixed10 GetCastingTime( const c_fixed10 & dexterity, const c_fixed10 & men, const float level )
|
|
{ return 100; /*return ( (dexterity * 7) + (men * 3) ) * 0.04 + 70;*/ }
|
|
|
|
// 기본이동속도: 캐릭터만 적용됨, 그 외는 DB에서 정의하는 값을 사용 (2007-03-24 리뉴얼 적용)
|
|
inline int GetBaseMoveSpeed() { return 120; }
|
|
|
|
// 최대 HP (2010-05-07 리뉴얼 적용)
|
|
inline int GetMaxHP( const c_fixed10 & vital, const float level, const c_fixed10 & fCM ) { return int(( vital * fCM * 33 ) + ( level * 20 )); }
|
|
|
|
// 최대 MP (2007-03-24 리뉴얼 적용)
|
|
inline int GetMaxMP( const c_fixed10 & intelligence, const float level, const c_fixed10 & fCM ) { return int(( intelligence * fCM * 30 ) + ( level * 20 )); }
|
|
|
|
template< typename INT_TYPE >
|
|
inline INT_TYPE GetIntValueByRandom( const double & fValue )
|
|
{
|
|
double fmod = (INT_TYPE)fValue + (double) ( XRandom() % 100 ) / 100.0f;
|
|
|
|
if( fmod < fValue )
|
|
{
|
|
return (INT_TYPE) fValue + 1;
|
|
}
|
|
|
|
return (INT_TYPE) fValue;
|
|
}
|
|
|
|
// 공격속도 (2010-05-07 리뉴얼 적용)
|
|
inline const c_fixed10 GetAttackSpeed( const c_fixed10 & agility )
|
|
{
|
|
return agility * 0.1 + 100;
|
|
}
|
|
|
|
// HP 리젠율% (60초당) (2007-03-24 리뉴얼 적용)
|
|
inline int GetHPRegenPercentage( const c_fixed10 & fCM )
|
|
{
|
|
return int( fCM * 5 );
|
|
}
|
|
|
|
// HP 리젠율+ (60초당) (2007-03-24 리뉴얼 적용)
|
|
inline int GetHPRegenPoint( float level )
|
|
{
|
|
return int( (level * 2) + 100 );
|
|
}
|
|
|
|
// MP 리젠율% (60초당) (2007-03-24 리뉴얼 적용)
|
|
inline int GetMPRegenPercentage( const c_fixed10 & fCM )
|
|
{
|
|
return int( fCM * 5 );
|
|
}
|
|
|
|
// MP 리젠율 (60초당) (2010-05-07 리뉴얼 적용)
|
|
inline int GetMPRegenPoint( float level, const c_fixed10 & mentality )
|
|
{
|
|
return int( level * 2 + 100 + mentality * 4.1 );
|
|
}
|
|
|
|
inline const c_fixed10 GetPerfectBlock()
|
|
{
|
|
return 0.0f; //20 AziaMafia Nerfing perfect block
|
|
}
|
|
|
|
float GetStaminaRatio( int level );
|
|
|
|
// 플레이어가 최대로 들 수 있는 무게 (2007-03-24 리뉴얼 적용)
|
|
int GetMaxWeight( int level, int strength );
|
|
|
|
// 물건을 주울 수 있는 거리
|
|
int GetPickableRange();
|
|
|
|
// 등급에 따른 아이템 레벨 제한
|
|
int GetItemLevelLimitByRank( int item_rank );
|
|
|
|
// 아이템 레벨에 따른 페널티
|
|
c_fixed10 GetItemLevelPenalty( int creature_level, int item_rank, int item_level, int min_item_usable_level );
|
|
|
|
// 등급별 아이템 권장레벨 조정 테이블
|
|
int GetItemRecommendModTable( int item_rank );
|
|
|
|
// 아이템 권장 레벨
|
|
int GetItemRecommendLevel( int item_rank, int item_level, int min_item_usable_level );
|
|
|
|
// 아이템 내구도 손상 포인트
|
|
int GetDecreasedEndurancePoint( int previous_endurance, int current_endurance );
|
|
|
|
// 에테리얼 내구도 소모율 계산(아이템과 관계 없이 미리 계산 가능한 부분과 아이템 정보가 반드시 필요한 부분 2가지로 분할)
|
|
const c_fixed10 GetEtherealDurabilityConsumeRate( const int nLevel, const int nJobID, const bool bIsAttack, const int nDamage );
|
|
const c_fixed10 GetEtherealDurabilityConsumeRateByItem( const int nRank, const int nGrade );
|
|
// 에테리얼 내구도 기본 소모량 얻기(StructCreature::DamageType에 따라 결정됨)
|
|
const int GetEtherealDurabilityBaseConsumption( const bool bIsAttack, /*StructCreature::DamageType*/ const int nDamageType );
|
|
|
|
// 각 레벨에 따른 성능 조정 (데미지, 방어구 동일)
|
|
const c_fixed10 GetItemValue( c_fixed10 item_current_value, int item_rank_value, int creature_level, int item_rank, int item_level, int min_item_usable_level );
|
|
|
|
// 기부 아이템에 대한 모럴 획득량
|
|
const c_fixed10 GetDonationRewardMoralPoint( const __int64 & nDonateGoldAmount );
|
|
|
|
const StructGold GetItemSellPrice( const StructGold & price, int rank, int lv, const bool same_price_for_buying, const bool ethereal_durability_exhausted, const bool is_equipment );
|
|
|
|
bool IsValidName( int code_page, const char * name, int nBufferSize, int nLimitMin, int nLimitMax );
|
|
bool ReformatName( char * name );
|
|
bool IsValidPartyName( const char * name, int nBufferSize, int nLimitMin, int nLimitMax );
|
|
|
|
int AppendOnetimePassword( char * pBuf, size_t buf_len, int one_time_key, int nSID, int nAccountID );
|
|
|
|
// 게임 중독 방지 시스템 관련 각종 수입 페널티
|
|
c_fixed10 GetGameTimeLimitPenalty( AR_TIME continuous_play_time );
|
|
|
|
// 펫 삽질 보상 중 지속효과 코드 얻기
|
|
const int GetPetShovelingRewardStateCode();
|
|
|
|
const c_fixed10 GetDifficultyBonus( const unsigned char nDifficulty );
|
|
|
|
int GetBattleArenaTeamNameStringID( int nTeamNo, bool bWithColorTag );
|
|
time_t GetBattleArenaBlockDuration( int nPenaltyCount );
|
|
time_t GetBattleArenaPenaltyDuration( int nPenaltyCount );
|
|
|
|
const int g_pAreaRect[16][14][4] =
|
|
{
|
|
{
|
|
{ 3, 3, 5, 5 },
|
|
{ 4, 4, 5, 5 },
|
|
{ 2, 2, 6, 5 },
|
|
{ 0, 0, 4, 4 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 7, 6 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 4, 4, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 4, 4, 8 },
|
|
{ 4, 4, 8, 8 },
|
|
{ 0, 4, 4, 8 },
|
|
{ 4, 4, 8, 8 },
|
|
{ 4, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 1, 1, 7, 7 },
|
|
{ 1, 0, 8, 8 },
|
|
{ 2, 1, 5, 5 },
|
|
{ 4, 4, 8, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 6, 3, 8 },
|
|
{ 4, 3, 8, 8 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 5, 1, 8, 5 },
|
|
{ 1, 3, 7, 7 },
|
|
{ 4, 0, 8, 4 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 7, 8, 8 },
|
|
{ 4, 0, 8, 5 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 4, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 1, 1, 3, 2 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 1, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 5, 8 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 4, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 3, 3, 6, 6 },
|
|
{ 2, 2, 6, 5 },
|
|
{ 3, 3, 6, 5 },
|
|
{ 1, 1, 5, 5 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 8, 8, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 3, 3, 5, 5 },
|
|
{ 3, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 1, 1, 5, 5 },
|
|
{ 1, 1, 5, 5 },
|
|
{ 1, 1, 5, 5 },
|
|
{ 1, 6, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 2, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 4, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 8, 5 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 2, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 4, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 1, 1, 6, 5 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 1, 0, 8, 8 },
|
|
{ 0, 0, 7, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 7, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 5, 1, 8, 5 },
|
|
{ 3, 3, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 3, 3, 6, 6 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 1, 0, 8, 8 },
|
|
{ 0, 0, 7, 7 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 7, 6 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 0, 0, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 8, 8, 8, 8 },
|
|
{ 8, 8, 8, 8 },
|
|
{ 0, 0, 8, 7 },
|
|
{ 0, 0, 8, 8 },
|
|
{ 0, 0, 7, 6 },
|
|
{ 0, 0, 7, 7 },
|
|
{ 3, 4, 8, 8 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 0, 0, 8, 8 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 4, 3, 8, 8 },
|
|
{ 4, 3, 8, 8 },
|
|
{ 4, 3, 8, 8 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 2, 2, 5, 6 },
|
|
{ 0, 0, 0, 0 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 4, 4, 8, 8 },
|
|
{ 0, 0, 0, 0 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 }
|
|
},
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 },
|
|
{ 0, 0, 0, 0 }
|
|
}
|
|
};
|
|
|
|
};
|