code stringlengths 1 2.06M | language stringclasses 1 value |
|---|---|
// 5th step - inserting thread synchronization
#include "DSWP.h"
using namespace llvm;
using namespace std;
void DSWP::insertSynchronization(Loop *L) {
//this->insertSynDependecy(L);
cout << "inserting sychronization" << endl;
int channel = 0;
for (unsigned int i = 0; i < allEdges.size(); i++) {
Edge e = allEdges[i];
// int t1 = assigned[sccId[e.u]];
// int t2 = assigned[sccId[e.v]];
// if (t1 == t2) //they are in same thread, therefore no need to syn
// continue;
for (int utr = 0; utr < MAX_THREAD; utr++) {
for (int vtr = 0; vtr < MAX_THREAD; vtr++) {
if (utr == vtr)
continue;
if (getInstAssigned(e.u) != utr)
continue;
if (instMap[utr][e.u] == NULL || instMap[vtr][e.v] == NULL)
continue;
Instruction * nu = dyn_cast<Instruction>(instMap[utr][e.u]);
Instruction * nv = dyn_cast<Instruction>(instMap[vtr][e.v]);
if (nu == NULL || nv == NULL)
continue;
insertProduce(nu, nv, e.dtype, channel, utr, vtr);
insertConsume(nu, nv, e.dtype, channel, utr, vtr);
channel++;
}
}
// if (isa<TerminatorInst>(e.v)) { //so e.v is a branch that could be copy into many thread
// //vector<Value*> termList = termMap[e.v];
// for (unsigned j = 0; j < MAX_THREAD; j++) {
// Value *vv = instMap[j][e.v];
// if (vv == NULL)
// continue;
// //insertProduce(dyn_cast<Instruction>(oldToNew[e.u]), dyn_cast<Instruction>(oldToNew[e.v]), e.dtype, channel);
// //insertConsume(dyn_cast<Instruction>(oldToNew[e.u]), dyn_cast<Instruction>(vv), e.dtype, channel);
// channel++;
// }
// } else {
//
// //should get thread num first!!
// int uthr = this->getInstAssigned(e.u);
// int vthr = this->getInstAssigned(e.v);
//// e.u->dump();
//// e.v->dump();
//// Value *tu = oldToNew[e.u];
//// tu->dump();
//// Instruction *nu = dyn_cast<Instruction>(tu);
// //Instruction *nv = dyn_cast<Instruction>(oldToNew[e.u]);
//
// insertProduce(dyn_cast<Instruction>(instMap[uthr][e.u]), dyn_cast<Instruction>(instMap[vthr][e.v]), e.dtype, channel, uthr, vthr);
// insertConsume(dyn_cast<Instruction>(instMap[uthr][e.u]), dyn_cast<Instruction>(instMap[vthr][e.v]), e.dtype, channel, uthr, vthr);
// channel++;
// }
}
//cout << channel << endl;
// // remaining functions are auxiliary
// for (unsigned i = 1; i < this->allFunc.size(); i++) {
// Function *curr = this->allFunc[i];
// // check each instruction and insert flows
// }
}
void DSWP::insertSynDependecy(Loop *L) {
MemoryDependenceAnalysis &mda = getAnalysis<MemoryDependenceAnalysis>();
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = &(*ii);
MemDepResult mdr = mda.getDependency(inst);
if (mdr.isDef()) {
Instruction *dep = mdr.getInst();
if (isa<LoadInst> (inst)) {
if (isa<LoadInst> (dep)) {
addEdge(dep, inst, DSYN); //READ AFTER READ
}
}
}
}
}
}
void DSWP::insertProduce(Instruction * u, Instruction *v, DType dtype, int channel, int uthread, int vthread) {
Function *fun = module->getFunction("sync_produce");
vector<Value*> args;
Instruction *insPos = u->getNextNode();
if (insPos == NULL) {
error("here cannot be null");
}
//if (isa<BranchInst>(u)) {
// error("I don't know how do deal with it");
// return;
//}
if (dtype == REG) { //register dep
CastInst *cast;
if (u->getType()->isIntegerTy()) {
cast = new SExtInst(u, eleType, u->getNameStr() + "_64");
}
else if (u->getType()->isFloatingPointTy()) {
if (u->getType()->isFloatTy()) {
error("float sucks");
}
cast = new BitCastInst(u, eleType, u->getNameStr() + "_64");
}
else if (u->getType()->isPointerTy()){
cast = new PtrToIntInst(u, eleType, u->getNameStr() + "_64"); //cast value
} else {
error("what's the hell type");
}
cast->insertBefore(insPos);
args.push_back(cast); //push the value
}
else if (dtype == DTRUE) { //true dep
error("check mem dep!!");
StoreInst *store = dyn_cast<StoreInst>(u);
if (store == NULL) {
error("not true dependency!");
}
BitCastInst *cast = new BitCastInst(store->getOperand(0), Type::getInt8PtrTy(*context), u->getNameStr() + "_ptr");
cast->insertBefore(insPos);
args.push_back(cast); //push the value //insert call
} else { //others
args.push_back(Constant::getNullValue( Type::getInt64Ty(*context) ) ); //just a dummy value
}
args.push_back(ConstantInt::get(Type::getInt32Ty(*context), channel));
CallInst *call = CallInst::Create(fun, args.begin(), args.end()); //call it
// call->setName("p" + channel);
call->insertBefore(insPos); //insert call
}
void DSWP::insertConsume(Instruction * u, Instruction *v, DType dtype, int channel, int uthread, int vthread) {
// int uthread = this->getNewInstAssigned(u);
// int vthread = this->getNewInstAssigned(v);
Value *oldu = newToOld[u];
Function *fun = module->getFunction("sync_consume");
vector<Value*> args;
args.push_back(ConstantInt::get(Type::getInt32Ty(*context), channel));
CallInst *call = CallInst::Create(fun, args.begin(), args.end(), "c" + itoa(channel));
call->insertBefore(v);
if (dtype == REG) {
CastInst *cast;
if (u->getType()->isIntegerTy()) {
cast = new TruncInst(call, u->getType(), call->getNameStr() + "_val");
}
else if (u->getType()->isFloatingPointTy()) {
if (u->getType()->isFloatTy())
error("cannot deal with double");
cast = new BitCastInst(call, u->getType(), call->getNameStr() + "_val"); //cast value
}
else if (u->getType()->isPointerTy()){
cast = new IntToPtrInst(call, u->getType(), call->getNameStr() + "_val"); //cast value
} else {
error("what's the hell type");
}
cast->insertBefore(v);
// for (unsigned i = 0; i < v->getNumOperands(); i++) {
// Value *op = v->getOperand(i);
// int opthread = this->getNewInstAssigned(op);
// if (op == u) {
// v->setOperand(i, cast);
// }
// }
//cout << "replace reg" << endl;
//TODO perhaps also need to replace other elements after this User
for (Instruction::use_iterator ui = oldu->use_begin(); ui != oldu->use_end(); ui++) { // this is diff from next block for DTRUE
Instruction *user = dyn_cast<Instruction>(*ui);
if (user == NULL) {
error("how could it be NULL");
}
// int userthread = this->getNewInstAssigned(user);
if (user->getParent()->getParent() != v->getParent()->getParent()) {
continue;
}
//user->dump();
for (unsigned i = 0; i < user->getNumOperands(); i++) {
Value * op = user->getOperand(i);
if (op == oldu) {
user->setOperand(i, cast);
}
}
//cast->dump();
//user->dump();
//cout <<"replace operand" << endl;
}
} else if (dtype == DTRUE) { //READ after WRITE
error("check mem dep!!");
if (!isa<LoadInst>(v)) {
error("not true dependency");
}
BitCastInst *cast = new BitCastInst(call, v->getType(), call->getNameStr() + "_ptr");
cast->insertBefore(v);
//replace the v with 'cast' in v's thread: (other thread with be dealed using dependence)
for (Instruction::use_iterator ui = v->use_begin(); ui != v->use_end(); ui++) {
Instruction *user = dyn_cast<Instruction>(*ui);
if (user == NULL) {
error("how could it be NULL");
}
// int userthread = this->getNewInstAssigned(user);
if (user->getParent()->getParent() != v->getParent()->getParent()) {
continue;
}
for (unsigned i = 0; i < user->getNumOperands(); i++) {
Value * op = user->getOperand(i);
if (op == v) {
user->setOperand(i, cast);
}
}
}
} else {
}
}
| C++ |
//include the public part of DSWP
#include "DSWP.h"
using namespace llvm;
using namespace std;
QNode::QNode(int u, int latency) {
this->u = u;
this->latency = latency;
}
bool QNode::operator < (const QNode &y) const {
return latency < y.latency;
}
Edge::Edge(Instruction *u, Instruction *v, DType dtype) {
this->u = u;
this->v = v;
this->dtype = dtype;
}
char DSWP::ID = 0;
RegisterPass<DSWP> X("dswp", "15745 Decoupled Software Pipeline");
DSWP::DSWP() : LoopPass (ID){
loopCounter = 0;
}
bool DSWP::doInitialization(Loop *L, LPPassManager &LPM) {
header = L->getHeader();
exit = L->getExitBlock();
func = header->getParent();
module = func->getParent();
context = &module->getContext();
eleType = Type::getInt64Ty(*context);
loopCounter++;
if (exit == NULL) {
error("exit not unique!");
}
Function * produce = module->getFunction("sync_produce");
if (produce == NULL) { //the first time, we need to link them
//add sync_produce function
vector<const Type *> produce_arg;
produce_arg.push_back(eleType);
produce_arg.push_back(Type::getInt32Ty(*context));
FunctionType *produce_ft = FunctionType::get(Type::getVoidTy(*context), produce_arg, false);
produce = Function::Create(produce_ft, Function::ExternalLinkage, "sync_produce", module);
produce->setCallingConv(CallingConv::C);
//add syn_consume function
vector<const Type *> consume_arg;
consume_arg.push_back(Type::getInt32Ty(*context));
FunctionType *consume_ft = FunctionType::get(eleType, consume_arg, false);
Function *consume = Function::Create(consume_ft, Function::ExternalLinkage, "sync_consume", module);
consume->setCallingConv(CallingConv::C);
//add sync_join
FunctionType *join_ft = FunctionType::get(Type::getVoidTy(*context), false);
Function *join = Function::Create(join_ft, Function::ExternalLinkage, "sync_join", module);
join->setCallingConv(CallingConv::C);
//add sync_init
FunctionType *init_ft = FunctionType::get(Type::getVoidTy(*context), false);
Function *init = Function::Create(init_ft, Function::ExternalLinkage, "sync_init", module);
init->setCallingConv(CallingConv::C);
//add sync_delegate
vector<const Type *> argFunArg;
argFunArg.push_back(Type::getInt8PtrTy(*context));
FunctionType * argFun = FunctionType::get(Type::getInt8PtrTy(*context), argFunArg, false);
PointerType * arg2 = PointerType::get(argFun, 0);
PointerType * arg3 = PointerType::get(eleType, 0);
vector<const Type *> delegate_arg;
delegate_arg.push_back(Type::getInt32Ty(*context));
delegate_arg.push_back(arg2);
delegate_arg.push_back(arg3);
FunctionType *delegate_ft = FunctionType::get(Type::getVoidTy(*context), delegate_arg, false);
Function *delegate = Function::Create(delegate_ft, Function::ExternalLinkage, "sync_delegate", module);
delegate->setCallingConv(CallingConv::C);
//add show value
vector<const Type *> show_arg;
show_arg.push_back(Type::getInt64Ty(*context));
FunctionType *show_ft = FunctionType::get(Type::getVoidTy(*context), show_arg, false);
Function *show = Function::Create(show_ft, Function::ExternalLinkage, "showValue", module);
show->setCallingConv(CallingConv::C);
//add showPlace value
vector<const Type *> show2_arg;
FunctionType *show2_ft = FunctionType::get(Type::getVoidTy(*context), show2_arg, false);
Function *show2 = Function::Create(show2_ft, Function::ExternalLinkage, "showPlace", module);
show2->setCallingConv(CallingConv::C);
//add showPtr value
vector<const Type *> show3_arg;
show3_arg.push_back(Type::getInt8PtrTy(*context));
FunctionType *show3_ft = FunctionType::get(Type::getVoidTy(*context), show3_arg, false);
Function *show3 = Function::Create(show3_ft, Function::ExternalLinkage, "showPtr", module);
show3->setCallingConv(CallingConv::C);
}
return true;
}
void DSWP::getAnalysisUsage(AnalysisUsage &AU) const {
AU.addRequired<LoopInfo>();
AU.addRequired<PostDominatorTree>();
AU.addRequired<AliasAnalysis>();
AU.addRequired<MemoryDependenceAnalysis>();
}
void DSWP::initilize(Loop *L) {
}
bool DSWP::runOnLoop(Loop *L, LPPassManager &LPM) {
if (L->getLoopDepth() != 1) //ONLY care about top level loops
return false;
if (generated.find(L->getHeader()->getParent()) != generated.end()) //this is the generated code
return false;
cout << "///////////////////////////// we are running on a loop" << endl;
buildPDG(L);
showGraph(L);
findSCC(L);
buildDAG(L);
showDAG(L);
threadPartition(L);
showPartition(L);
getLiveinfo(L);
showLiveInfo(L);
preLoopSplit(L);
loopSplit(L);
insertSynchronization(L);
clearup(L);
cout << "//////////////////////////// we finsih run on a loop " << endl;
return true;
}
void DSWP::addEdge(Instruction *u, Instruction *v, DType dtype) {
pdg[u]->push_back(Edge(u, v, dtype));
allEdges.push_back(Edge(u, v, dtype));
rev[v]->push_back(Edge(v, u, dtype));
}
bool DSWP::checkEdge(Instruction *u, Instruction *v) {
for (vector<Edge>::iterator it = pdg[u]->begin(); it != pdg[v]->end(); it++) {
if (it->v == v) {
//TODO report something
return true;
}
}
return false;
}
| C++ |
#include "LivenessAnalysis.h"
LivenessAnalysis::LivenessAnalysis() :
FunctionPass(ID) {
}
LivenessAnalysis::~LivenessAnalysis() {
}
void LivenessAnalysis::db() {
std::cout << "Here I come\n";
}
void LivenessAnalysis::setDefinitionVector(vector<Value *> allDef) {
this->allDef = allDef;
for (unsigned i = 0; i < allDef.size(); i++) {
defIndex[allDef[i]] = i;
}
}
bool LivenessAnalysis::runOnFunction(Function &F) {
allDef.clear();
defIndex.clear();
//open file to write infomation
std::string name = F.getParent()->getModuleIdentifier() + ".finfo";
ofstream file((name.c_str()));
raw_os_ostream ost(file);
//find all definition and give them names (if they don't have one)
for (Function::ArgumentListType::iterator it = F.getArgumentList().begin(); it
!= F.getArgumentList().end(); it++) {
allDef.push_back(it);
defIndex[it] = allDef.size() - 1;
}
for (inst_iterator I = inst_begin(&F); I != inst_end(&F); ++I) {
Instruction *isn = &*I;
if (Utils::hasNewDef(isn)) {
if (!isn->hasName())
isn->setName(Utils::genId());
allDef.push_back(isn);
defIndex[isn] = allDef.size() - 1;
}
}
//solve the problem
map<Value*, DFAValue> &res = solve(&F);
//output the result
for (inst_iterator I = inst_begin(&F); I != inst_end(&F); ++I) {
Instruction *isn = &*I;
DFAValue &val = res[isn];
//val.show();
if (!isa<PHINode> (isn)) {
ost << "{ ";
for (unsigned i = 0; i < allDef.size(); i++)
if (val.get(i) == 1)
ost << allDef[i]->getNameStr() << " ";
ost << "}\n";
}
ost << "\t" << *isn << "\n\n";
}
return false;
}
DFAValue LivenessAnalysis::transfer(Instruction *isn, DFAValue value) {
DFAValue res = value;
if (Utils::hasNewDef(isn)) { //Out - Def
res.clear(defIndex[isn]);
}
if (isa<PHINode> (isn)) //just treat it a new defnition, the use of operands have been dealed in initilization
return res;
for (User::op_iterator it = isn->op_begin(); it != isn->op_end(); it++) {
Value *val = *it;
if (isa<Instruction> (val) || isa<Argument> (val)) { //now very clear here, why need this if
res.set(defIndex[val]);
}
}
return res;
}
void LivenessAnalysis::initialize(Function *fun) {
DFAValue top = DFAValue(allDef.size());
in.clear();
out.clear();
for (Function::iterator it = fun->getBasicBlockList().begin(); it
!= fun->getBasicBlockList().end(); it++) {
in[it] = top;
out[it] = top;
}
for (inst_iterator I = inst_begin(fun); I != inst_end(fun); ++I) {
PHINode *phi = dyn_cast<PHINode> (&*I);
if (!phi)
continue;
for (unsigned i = 0; i < phi->getNumIncomingValues(); i++) {
Value *val = phi->getIncomingValue(i);
BasicBlock *bb = NULL;
if (Instruction *inst = dyn_cast<Instruction>(val)) {
bb = inst->getParent();
}
if (isa<Argument> (val)) {
bb = &fun->getEntryBlock(); //I think the conversion should be done in the begin or the end of the entry block
}
if (bb) {
out[bb].set(defIndex[val]); //so the value must alive in the end of the block so it could do phi convert
}
}
}
}
DFAValue LivenessAnalysis::meet(DFAValue a, DFAValue b) {
return a | b;
}
bool LivenessAnalysis::isFoward() {
return false;
}
bool LivenessAnalysis::isVaribleLiveIn(Value * var, Value* position) {
int index = defIndex[var];
DFAValue value = in[position];
return value.get(index);
}
bool LivenessAnalysis::isVaribleLiveOut(Value * var, Value* position) {
int index = defIndex[var];
DFAValue value = out[position];
return value.get(index);
}
char LivenessAnalysis::ID = 0;
RegisterPass<LivenessAnalysis> Y("liveness-dswp", "15745: liveness Analysis");
| C++ |
//test
/*
* DFAValue.h
*
* Created on: Jan 29, 2011
* Author: Fuyao Zhao, Mark Hahnenberg
*/
#ifndef DFAVALUE_H_
#define DFAVALUE_H_
#include <vector>
using namespace std;
class DFAValue {
private:
vector<bool> bits;
public:
DFAValue();
DFAValue(int n); // the length of the bit vector is n;
//DFAValue(const DFAValue &y);
void set(int i); // set ith bit to one
void clear(int i); // set ith bit to zero
void set(); // set all bits to one
void clear(); // set all bits to zero
bool get(int i) const; // get the value of ith bit
void show(); //for debug
DFAValue operator & (const DFAValue &y) const;
DFAValue operator | (const DFAValue &y) const;
DFAValue operator - (const DFAValue &y) const; //todo if needed
bool operator == (const DFAValue &y) const;
bool operator != (const DFAValue &y) const;
};
#endif /* DFAVALUE_H_ */
| C++ |
/*
* DFAFramework.h
*
* Created on: Jan 29, 2011
* Author: Fuyao Zhao, Mark Hahnenberg
*/
#ifndef DFAFRAMEWORK_H_
#define DFAFRAMEWORK_H_
#include "llvm/Pass.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Value.h"
#include "llvm/Support/CFG.h"
#include "DFAValue.h"
#include <map>
using namespace llvm;
using namespace std;
class DFAFramework{
private:
/*
* Transfer Function for Basic block
*/
DFAValue transfer(BasicBlock *bb, DFAValue value);
/*
* do meet operator for block, according if it is forward
*/
DFAValue meetAll(BasicBlock *bb);
protected:
//store the value for in and out, value* could be either instruction * or block *
map<Value *, DFAValue> in;
map<Value *, DFAValue> out;
public:
//DFAFramework(bool foward, DFAValue boundary, DFAValue interior);
~DFAFramework();
/*
* get the in set
*/
map<Value *, DFAValue> &getIn();
/*
* get the out set
*/
map<Value *, DFAValue> &getOut();
/*
* solve the data flow problem
* return a map which maps every value (instruction or basic block to DFAValue)
*/
map<Value *, DFAValue> &solve(Function *fun);
/*
* Transfer Function for Instruction level, must be overridden
*/
virtual DFAValue transfer(Instruction *isn, DFAValue value) = 0;
/*
* Meet Operator in Data Flow Analysis, must be overridden
*/
virtual DFAValue meet(DFAValue a, DFAValue b) = 0;
/*
* Initialize the value, including dealing with the phi node
*/
virtual void initialize(Function *fun) = 0;
/*
* tell the framework whether the problem is a forward problem or backward problem
*/
virtual bool isFoward() = 0;
};
#endif /* DFAFRAMEWORK_H_ */
| C++ |
#include "DSWP.h"
using namespace llvm;
using namespace std;
void DSWP::showGraph(Loop *L) {
cout << "header:" << L->getHeader()->getNameStr() << endl;
cout << "exit:" << L->getExitBlock()->getNameStr() << endl; //TODO check different functions related to exit
cout << "num of blocks:" << L->getBlocks().size() << endl;
std::string name = "showgraph";
ofstream file((name.c_str()));
raw_os_ostream ost(file);
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
Instruction *inst = &(*ui);
vector<Edge> * edges = pdg[inst];
ost << dname[inst] << " " << *inst << ":\n";
ost << "\t";
for (vector<Edge>::iterator ei = edges->begin(); ei != edges->end(); ei ++) {
ost << dname[(ei->v)] << "[" << ei->dtype << "]\t";
}
ost << "\n\n";
}
}
}
void DSWP::showDAG(Loop *L) {
std::string name = "dag";
ofstream file((name.c_str()));
raw_os_ostream ost(file);
ost << "num:" << sccNum << "\n";
for (int i = 0; i < sccNum; i++) {
ost << "SCC " << i << ":";
vector<Instruction *> insts = this->InstInSCC[i];
for (vector<Instruction *>::iterator ii = insts.begin(); ii != insts.end(); ii++) {
Instruction *inst = *ii;
ost << dname[inst] << " ";
}
ost << "\n";
ost << "\tadjacent scc" << ":";
vector<int> *edges = this->dag[i];
for (unsigned i = 0; i < edges->size(); i++) {
ost << edges->at(i) << " ";
}
ost << "\n";
}
}
void DSWP::showPartition(Loop *L) {
std::string name = "partition";
ofstream file((name.c_str()));
raw_os_ostream ost(file);
ost << "latency: \n";
for (int i = 0; i < sccNum; i++) {
ost << i << " " << sccLatency[i] << "\n";
}
for (int i = 0; i < MAX_THREAD; i++) {
ost << "partition " << i << ":" << "\n";
vector<int> &nodes = part[i];
ost << "\t";
for(unsigned j = 0; j < nodes.size(); j++) {
ost << nodes[j] << " ";
}
ost << "\n";
}
}
void DSWP::showLiveInfo(Loop *L) {
cout << "live variable information" << endl;
for (int i = 0; i < livein.size(); i++) {
Value * val = livein[i];
cout << val->getNameStr() << "\t";
//val->getType()->dump();
//cout << endl;
}
cout << endl;
}
| C++ |
#include "Utils.h"
#include <iostream>
#include <cstdio>
#include <sstream>
using namespace std;
string itoa(int i) {
std::stringstream out;
out << i;
return out.str();
}
void error(const char *info) {
printf("%s\n", info);
}
void error(string info) {
printf("%s\n", info.c_str());
}
int Utils::id = 0;
string Utils::genId() {
std::stringstream out;
out << "t" << id++;
return out.str();
}
bool Utils::hasNewDef(Instruction *inst) {
if (isa<StoreInst>(inst))
return false;
if (isa<TerminatorInst>(inst))
return false;
return true;
}
| C++ |
//3rd step: thread partition
#include "DSWP.h"
using namespace llvm;
using namespace std;
void DSWP::threadPartition(Loop *L) {
//1. get total latency and latency for
assigned.clear();
sccLatency.clear();
int totalLatency = 0;
for (int i = 0; i < sccNum; i++)
sccLatency.push_back(0);
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = &(*ii);
int latency = getLatency(inst);
sccLatency[sccId[inst]] += latency;
totalLatency += latency;
}
}
int averLatency = totalLatency / MAX_THREAD;
cout << "latency info:" << totalLatency << " " << averLatency << endl;
for (int i = 0; i < sccNum; i++)
assigned.push_back(-2);
//-2: not assigned, and not in queue
//-1: not assigned, but in queue
//0 ~ MAX_THREAD, already been assigned, not in queue
int estLatency[MAX_THREAD] = {};
//TODO NOT SURE HERE IS RIGHT! header vs. preheader
int start = sccId[L->getHeader()->getFirstNonPHI()];
priority_queue<QNode> Q;
Q.push(QNode(start, sccLatency[start]));
for (int i = 0; i < MAX_THREAD; i++) {
while (!Q.empty()) {
QNode top = Q.top(); Q.pop();
assigned[top.u] = i;
estLatency[i] += top.latency;
//update the list
for (unsigned j = 0; j < dag[top.u]->size(); j++) {
int v = dag[top.u]->at(j);
if (assigned[v] > -2)
continue;
assigned[v] = -1;
Q.push(QNode(v, sccLatency[v]));
}
//check load balance
if (estLatency[i] >= averLatency) {
// cout << estLatency[i] << endl;
break;
}
}
}
//following is impossible since every time I let it bigger that aver
// if (!Q.empty()) {
// error("queue should be empty!");
// }
while (!Q.empty()) {
assigned[Q.top().u] = MAX_THREAD - 1;
Q.pop();
}
for (int i = 0; i < MAX_THREAD; i++)
part[i].clear();
for (int i = 0; i < sccNum; i++) {
// cout << i << " " << assigned[i] << endl;
part[assigned[i]].push_back(i);
}
for (int i = 0; i < MAX_THREAD; i++) {
cout << part[i].size() << endl;
}
}
int DSWP::getLatency(Instruction *I) { //Instruction Latency for Core 2, 65nm
int opcode = I->getOpcode();
int cost;
switch (opcode) {
// Terminator instructions
case 1: cost=1; break; // Return
case 2: cost=0; break; // Branc
case 3: cost=0; break; // Switch
// Standard binary operators
case 8: cost=1; break; // Add
case 9: cost=4; break; // FAdd
case 10: cost=1; break; // Sub
case 11: cost=4; break; // FSub
case 12: cost=3; break; // Mul
case 13: cost=4; break; // FMul
case 14: cost=17; break; // UDiv
case 15: cost=17; break; // SDiv
case 16: cost=24; break; // FDiv
case 17: cost=17; break; // URem
case 18: cost=17; break; // SRem
case 19: cost=24; break; // FRem
// logical operators (integer operands)
case 20: cost=7; break; // Shift left
case 21: cost=7; break; // Shift right
case 22: cost=7; break; // Shifr right (arithmetic)
case 23: cost=1; break; // And
case 24: cost=1; break; // Or
case 25: cost=1; break; // Xor
// Memory ops
case 26: cost=2; break; // Alloca
case 27: cost=2; break; // Load
case 28: cost=2; break; // Store
case 29: cost=1; break; // GetElementPtr
// Cast operators
case 30: cost=1; break; // Truncate integers
case 31: cost=1; break; // Zero extend integers
case 32: cost=1; break; // Sign extend integers
case 33: cost=4; break; // FPtoUI
case 34: cost=4; break; // FPtoSI
case 35: cost=4; break; // UItoFP
case 36: cost=4; break; // SItoFP
case 37: cost=4; break; // FPTrunc
case 38: cost=4; break; // FPExt
case 39: cost=2; break; // PtrToInt
case 40: cost=2; break; // IntToPtr
case 41: cost=1; break; // Type cast
// Other
case 42: cost=1; break; // Integer compare
case 43: cost=1; break; // Float compare
case 44: cost=1; break; // PHI node
case 45: cost=50; break; // Call function (this one is really variable)
default: cost=1;
}
return (cost);
}
//int DSWP::getLatency(Instruction *I) {
// int opcode = I->getOpcode();
//
// //copy from dswp583 google project site TODO this table is obviously not right!
// int cost;
// // These are instruction latencies for an AMD K10
// // (Well, most of them are, some I just made up)
// switch (opcode) {
// // Terminator instructions
// case 1: cost=2; break; // Return
// case 2: cost=3; break; // Branch //TODO NOT RIGHT
// case 3: cost=3; break; // Switch
//
// // Standard binary operators
// case 8: cost=1; break; // Add
// case 9: cost=4; break; // FAdd
// case 10: cost=1; break; // Sub
// case 11: cost=4; break; // FSub
// case 12: cost=3; break; // Mul
// case 13: cost=4; break; // FMul
// case 14: cost=17; break; // UDiv
// case 15: cost=17; break; // SDiv
// case 16: cost=24; break; // FDiv
// case 17: cost=17; break; // URem
// case 18: cost=17; break; // SRem
// case 19: cost=24; break; // FRem
//
// // logical operators (integer operands)
// case 20: cost=7; break; // Shift left
// case 21: cost=7; break; // Shift right
// case 22: cost=7; break; // Shifr right (arithmetic)
// case 23: cost=1; break; // And
// case 24: cost=1; break; // Or
// case 25: cost=1; break; // Xor
//
// // Memory ops
// case 26: cost=2; break; // Alloca
// case 27: cost=2; break; // Load
// case 28: cost=2; break; // Store
// case 29: cost=1; break; // GetElementPtr
//
// // Cast operators
// case 30: cost=1; break; // Truncate integers
// case 31: cost=1; break; // Zero extend integers
// case 32: cost=1; break; // Sign extend integers
// case 33: cost=4; break; // FPtoUI
// case 34: cost=4; break; // FPtoSI
// case 35: cost=4; break; // UItoFP
// case 36: cost=4; break; // SItoFP
// case 37: cost=4; break; // FPTrunc
// case 38: cost=4; break; // FPExt
// case 39: cost=2; break; // PtrToInt
// case 40: cost=2; break; // IntToPtr
// case 41: cost=1; break; // Type cast
//
// // Other
// case 42: cost=1; break; // Integer compare
// case 43: cost=1; break; // Float compare
// case 44: cost=1; break; // PHI node
// case 45: cost=50; break; // Call function (this one is really variable)
//
// default: cost=1;
// }
//
// return (cost);
//}
int DSWP::getInstAssigned(Value *inst) {
return assigned[sccId[dyn_cast<Instruction>(inst)]];
}
int DSWP::getNewInstAssigned(Value *inst) {
if (isa<TerminatorInst>(inst)) {
error("cannot be term");
}
return getInstAssigned(newToOld[inst]);
}
| C++ |
/*
* DSWP_PRE.cpp
*
* Created on: Apr 27, 2011
* Author: fuyaoz
*/
#include "DSWP_PRE.h"
DSWP_PRE::DSWP_PRE() : ModulePass(ID) {
}
DSWP_PRE::~DSWP_PRE() {
}
bool DSWP_PRE::runOnModule(Module &M) {
//for (Function::iterator)
for (Module::global_iterator gi = M.global_begin(); gi != M.global_end(); gi++) {
Value *inst = gi;
if (inst->getType()->isFloatTy()) {
}
}
return true;
}
char DSWP_PRE::ID = 0;
RegisterPass<DSWP_PRE> Z("dswp-pre", "preprocess of dswp");
| C++ |
#ifndef LIVE_H_
#define LIVE_H_
#include "DFAFramework.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/Support/raw_os_ostream.h"
#include "Utils.h"
#include <vector>
#include <iostream>
#include <ostream>
#include <fstream>
#include <map>
#include <list>
using namespace std;
using namespace llvm;
class LivenessAnalysis: public FunctionPass, public DFAFramework {
private:
vector<Value *> allDef;
map<Value*, int> defIndex;
public:
static char ID;
LivenessAnalysis();
~LivenessAnalysis();
void db();
void setDefinitionVector(vector<Value *> allDef);
virtual bool runOnFunction(Function &F);
virtual DFAValue transfer(Instruction *isn, DFAValue value);
virtual void initialize(Function *fun);
virtual DFAValue meet(DFAValue a, DFAValue b);
virtual bool isFoward();
bool isVaribleLiveIn(Value * var, Value* position);
bool isVaribleLiveOut(Value * var, Value* position);
};
#endif
| C++ |
//===--- raw_os_ostream.cpp - Implement the raw_os_ostream class ----------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This implements support adapting raw_ostream to std::ostream.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/raw_os_ostream.h"
#include <ostream>
using namespace llvm;
//===----------------------------------------------------------------------===//
// raw_os_ostream
//===----------------------------------------------------------------------===//
raw_os_ostream::~raw_os_ostream() {
flush();
}
void raw_os_ostream::write_impl(const char *Ptr, size_t Size) {
OS.write(Ptr, Size);
}
uint64_t raw_os_ostream::current_pos() const { return OS.tellp(); }
| C++ |
#ifndef UTIL_H_
#define UTIL_H_
#include "llvm/Instructions.h"
#include <iostream>
#include <string>
#include <sstream>
#include <string>
#include "Utils.h"
using namespace llvm;
using namespace std;
string itoa(int i);
void error(const char * info);
void error(string info);
class Utils {
private:
static int id;
public:
static string genId(); //return a new identifier
static bool hasNewDef(Instruction *inst); //check if the instruction has the form of %x = (some expresssion)
};
#endif /* UTIL_H_ */
| C++ |
#ifndef DSWP_H_
#define DSWP_H_
#include "llvm/Pass.h"
#include "llvm/Analysis/LoopPass.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Value.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/Analysis/PostDominators.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/InstIterator.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Support/IRBuilder.h"
#include "llvm/LLVMContext.h"
#include "LivenessAnalysis.h"
#include "Utils.h"
#include <ostream>
#include <fstream>
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
using namespace llvm;
using namespace std;
static const int MAX_THREAD = 2;
//REG: register dependency
//DTRUE: data dependency - read after write
//DANTI: data dependency - write after read
//DOUT: data dependency - write after write
//DSYN: data dependency - read after read
enum DType {
REG, DTRUE, DANTI, DOUT, DSYN, CONTROL, CONTROL_LC
};
struct Edge {
Instruction *u, *v;
DType dtype;
Edge(Instruction *u, Instruction *v, DType dtype);
};
struct QNode {
int u;
int latency;
QNode(int u, int latency);
bool operator <(const QNode &y) const;
};
class DSWP: public LoopPass {
private:
//neccesary information
Module * module;
Function *func;
BasicBlock * header;
BasicBlock * exit;
LLVMContext *context;
const Type *eleType;
int loopCounter;
set<Function *> generated; //all generated function that should not be run in the pass
//
//part 0
void addEdge(Instruction *u, Instruction *v, DType dtype);
bool checkEdge(Instruction *u, Instruction *v);
//part 1: program dependence graph
void buildPDG(Loop *L);
void checkControlDependence(BasicBlock *a, BasicBlock *b,
PostDominatorTree &pdt);
void addControlDependence(BasicBlock *a, BasicBlock *b);
//part 2: scc and dag
void findSCC(Loop *L);
void buildDAG(Loop *L);
void dfs1(Instruction *inst);
void dfs2(Instruction *inst);
//program dependence graph
map<Instruction *, vector<Edge> *> pdg;
//reverse graph for scc
map<Instruction *, vector<Edge> *> rev;
//dag
map<int, vector<int> *> dag;
//edge table, all the dependency relationship
vector<Edge> allEdges;
vector<vector<Instruction *> > InstInSCC;
//the father node for each block in post dominator tree
map<BasicBlock *, BasicBlock *> pre;
//total number of scc
int sccNum;
//map instruction to sccId
map<Instruction *, int> sccId;
//tmp flag
map<Instruction *, bool> used;
//store the dfs sequence
vector<Instruction *> list;
BasicBlock * replaceBlock;
//part 3: thread partition
void threadPartition(Loop *L);
//get the latency estimate of a instruction
int getLatency(Instruction *I);
//assigned[i] = node i in dag has been assgined to assigned[i] thread
vector<int> assigned;
int getInstAssigned(Value *inst);
//part[i] = i thread contains part[i] nodes of the dag
vector<int> part[MAX_THREAD];
//set<BasicBlock *> BBS[MAX_THREAD];
//total lantency within a scc
vector<int> sccLatency;
//part 4: code splitting
void preLoopSplit(Loop *L);
void loopSplit(Loop *L);
void clearup(Loop *L);
//map<Value*, vector<Value*> > termMap; //map the new instruction to the old instu (terminators)
map<Value*, Value*> instMap[MAX_THREAD]; //map the new instruction to the old instuction
// map<Value *, Value *> oldToNew; //direct map without take thread number as arugment
map<Value *, Value *> newToOld;
map<Value *, int> newInstAssigned; //the assignment for each newly generated instruction
int getNewInstAssigned(Value *inst);
//the new functions (has already been inserted, waiting for syn)
vector<Function *> allFunc;
//get live variable infomration
void getLiveinfo(Loop * L);
vector<Value *> livein; //live in variable
vector<Value *> defin; //Variable generate in the loop
vector<Value *> liveout;
// part 5: synchronization insertion
void insertSynDependecy(Loop *L);
void insertSynchronization(Loop *L);
void insertProduce(Instruction * u, Instruction *v, DType dtype,
int channel, int uthread, int vthread);
void insertConsume(Instruction * u, Instruction *v, DType dtype,
int channel, int uthread, int vthread);
//test function
void showGraph(Loop *L);
//show DAC information
void showDAG(Loop *L);
//show partition
void showPartition(Loop *L);
//show live in and live out set
void showLiveInfo(Loop *L);
Utils util;
//give each instruction a name, including terminator instructions (which can not be setName)
map<Instruction *, string> dname;
void initilize(Loop *L);
public:
static char ID;
DSWP();
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
virtual bool runOnLoop(Loop *L, LPPassManager &LPM);
virtual bool doInitialization(Loop *, LPPassManager &LPM);
//virtual bool doFinalization();
};
#endif
| C++ |
/*
* DSWP_PRE.h
*
* Created on: Apr 27, 2011
* Author: fuyaoz
*/
#ifndef DSWP_PRE_H_
#define DSWP_PRE_H_
#include "llvm/Pass.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Value.h"
#include "llvm/Support/CFG.h"
#include <vector>
#include <iostream>
#include <ostream>
#include <fstream>
#include <map>
#include <list>
using namespace std;
using namespace llvm;
class DSWP_PRE : public ModulePass {
public:
static char ID;
DSWP_PRE();
virtual ~DSWP_PRE();
virtual bool runOnModule(Module &M);
};
#endif /* DSWP_PRE_H_ */
| C++ |
//1st step: create dependence graph
#include "DSWP.h"
using namespace llvm;
using namespace std;
void DSWP::addControlDependence(BasicBlock *a, BasicBlock *b) {
//TODO: dinstingush the loop carried
Instruction *u = &a->getInstList().back();
Instruction *v = b->getFirstNonPHI();
addEdge(u, v, CONTROL);
}
void DSWP::checkControlDependence(BasicBlock *a, BasicBlock *b, PostDominatorTree &pdt) {
BasicBlock *lca = pdt.findNearestCommonDominator(a, b);
cout << a->getNameStr() << " " << b->getNameStr() << " " << lca->getNameStr() << endl;
if (lca == pre[a]) { //case 1
BasicBlock *BB = b;
while (BB != lca) {
addControlDependence(a, BB);
BB = pre[BB];
}
} else if (lca == a) { //case 2: capture loop dependence
BasicBlock *BB = b;
while (BB != pre[a]) {
cout << "\t" << a->getNameStr() << " " << BB->getNameStr() << endl;
addControlDependence(a, BB);
BB = pre[BB];
}
} else {
error("unknow case in checkControlDependence!");
}
}
void DSWP::buildPDG(Loop *L) {
//Initialize PDG
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
Instruction *inst = &(*ui);
//standardlize the name for all expr
if (util.hasNewDef(inst)) {
inst->setName(util.genId());
dname[inst] = inst->getNameStr();
} else {
dname[inst] = util.genId();
}
pdg[inst] = new vector<Edge>();
rev[inst] = new vector<Edge>();
}
}
//LoopInfo &li = getAnalysis<LoopInfo>();
/*
* Memory dependency analysis
*/
MemoryDependenceAnalysis &mda = getAnalysis<MemoryDependenceAnalysis>();
for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = &(*ii);
//data dependence = register dependence + memory dependence
//begin register dependence
for (Value::use_iterator ui = ii->use_begin(); ui != ii->use_end(); ui++) {
if (Instruction *user = dyn_cast<Instruction>(*ui)) {
addEdge(inst, user, REG);
}
}
//finish register dependence
//begin memory dependence
MemDepResult mdr = mda.getDependency(inst);
//TODO not sure clobbers mean!!
if (mdr.isDef()) {
Instruction *dep = mdr.getInst();
if (isa<LoadInst>(inst)) {
if (isa<StoreInst>(dep)) {
addEdge(dep, inst, DTRUE); //READ AFTER WRITE
}
}
if (isa<StoreInst>(inst)) {
if (isa<LoadInst>(dep)) {
addEdge(dep, inst, DANTI); //WRITE AFTER READ
}
if (isa<StoreInst>(dep)) {
addEdge(dep, inst, DOUT); //WRITE AFTER WRITE
}
}
//READ AFTER READ IS INSERT AFTER PDG BUILD
}
//end memory dependence
}//for ii
}//for bi
/*
* begin control dependence
*/
PostDominatorTree &pdt = getAnalysis<PostDominatorTree>();
//cout << pdt.getRootNode()->getBlock()->getNameStr() << endl;
/*
* alien code part 1
*/
LoopInfo *LI = &getAnalysis<LoopInfo>();
std::set<BranchInst*> backedgeParents;
for (Loop::block_iterator bi = L->getBlocks().begin(); bi
!= L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction *inst = ii;
if (BranchInst *brInst = dyn_cast<BranchInst>(inst)) {
// get the loop this instruction (and therefore basic block) belongs to
Loop *instLoop = LI->getLoopFor(BB);
bool branchesToHeader = false;
for (int i = brInst->getNumSuccessors() - 1; i >= 0
&& !branchesToHeader; i--) {
// if the branch could exit, store it
if (LI->getLoopFor(brInst->getSuccessor(i)) != instLoop) {
branchesToHeader = true;
}
}
if (branchesToHeader) {
backedgeParents.insert(brInst);
}
}
}
}
//build information for predecessor of blocks in post dominator tree
for (Function::iterator bi = func->begin(); bi != func->end(); bi++) {
BasicBlock *BB = bi;
DomTreeNode *dn = pdt.getNode(BB);
for (DomTreeNode::iterator di = dn->begin(); di != dn->end(); di++) {
BasicBlock *CB = (*di)->getBlock();
pre[CB] = BB;
}
}
//
// //add dependency within a basicblock
// for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
// BasicBlock *BB = *bi;
// Instruction *pre = NULL;
// for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
// Instruction *inst = &(*ui);
// if (pre != NULL) {
// addEdge(pre, inst, CONTROL);
// }
// pre = inst;
// }
// }
// //the special kind of dependence need loop peeling ? I don't know whether this is needed
// for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
// BasicBlock *BB = *bi;
// for (succ_iterator PI = succ_begin(BB); PI != succ_end(BB); ++PI) {
// BasicBlock *succ = *PI;
//
// checkControlDependence(BB, succ, pdt);
// }
// }
/*
* alien code part 2
*/
// add normal control dependencies
// loop through each instruction
for (Loop::block_iterator bbIter = L->block_begin(); bbIter
!= L->block_end(); ++bbIter) {
BasicBlock *bb = *bbIter;
// check the successors of this basic block
if (BranchInst *branchInst = dyn_cast<BranchInst>(bb->getTerminator())) {
if (branchInst->getNumSuccessors() > 1) {
BasicBlock * succ = branchInst->getSuccessor(0);
// if the successor is nested shallower than the current basic block, continue
if (LI->getLoopDepth(bb) < LI->getLoopDepth(succ)) {
continue;
}
// otherwise, add all instructions to graph as control dependence
while (succ != NULL && succ != bb && LI->getLoopDepth(succ)
>= LI->getLoopDepth(bb)) {
Instruction *terminator = bb->getTerminator();
for (BasicBlock::iterator succInstIter = succ->begin(); &(*succInstIter)
!= succ->getTerminator(); ++succInstIter) {
addEdge(terminator, &(*succInstIter), CONTROL);
}
if (BranchInst *succBrInst = dyn_cast<BranchInst>(succ->getTerminator())) {
if (succBrInst->getNumSuccessors() > 1) {
addEdge(terminator, succ->getTerminator(),
CONTROL);
}
}
if (BranchInst *br = dyn_cast<BranchInst>(succ->getTerminator())) {
if (br->getNumSuccessors() == 1) {
succ = br->getSuccessor(0);
} else {
succ = NULL;
}
} else {
succ = NULL;
}
}
}
}
}
/*
* alien code part 3
*/
for (std::set<BranchInst*>::iterator exitIter = backedgeParents.begin(); exitIter != backedgeParents.end(); ++exitIter) {
BranchInst *exitBranch = *exitIter;
if (exitBranch->isConditional()) {
BasicBlock *header = LI->getLoopFor(exitBranch->getParent())->getHeader();
for (BasicBlock::iterator ctrlIter = header->begin(); ctrlIter != header->end(); ++ctrlIter) {
addEdge(exitBranch, &(*ctrlIter), CONTROL);
}
}
}
//end control dependence
}
| C++ |
//4th step: code splitting
#include "DSWP.h"
using namespace llvm;
using namespace std;
void DSWP::preLoopSplit(Loop *L) {
allFunc.clear();
/*
* Insert a new block
*/
replaceBlock = BasicBlock::Create(*context, "loop-replace", func);
BranchInst *brInst = BranchInst::Create(exit, replaceBlock);
replaceBlock->moveBefore(exit);
if (L->contains(exit)) {
error("don't know why");
}
//BranchInst *brInst = BranchInst::Create(exit);
//newBlock->getInstList().push_back(brInst);
//every block to header (except the ones in the loop), will now redirect to here
for (pred_iterator PI = pred_begin(header); PI != pred_end(header); ++PI) {
BasicBlock *pred = *PI;
if (L->contains(pred)) {
continue;
}
TerminatorInst *termInst = pred->getTerminator();
for (unsigned i = 0; i < termInst->getNumOperands(); i++) {
BasicBlock *bb = dyn_cast<BasicBlock> (termInst->getOperand(i));
if (bb == header) {
termInst->setOperand(i, replaceBlock);
}
}
}
for (Loop::block_iterator li = L->block_begin(); li != L->block_end(); li++) {
BasicBlock *BB = *li;
if (BB == replaceBlock) {
error("the block should not appear here!");
}
}
/*
* prepare the function Type
*/
vector<const Type*> funArgTy;
PointerType* argPointTy = PointerType::get(Type::getInt8Ty(*context), 0);
funArgTy.push_back(argPointTy);
FunctionType *fType = FunctionType::get(Type::getInt8PtrTy(*context),
funArgTy, false);
//add functions
for (int i = 0; i < MAX_THREAD; i++) {
//create functions to each thread
Constant * c = module->getOrInsertFunction(itoa(loopCounter)
+ "_subloop_" + itoa(i), fType); //they both have same function type
if (c == NULL) {
error("no function!");
}
Function *func = cast<Function> (c);
func->setCallingConv(CallingConv::C);
allFunc.push_back(func);
generated.insert(func);
}
/*
* prepare the actual parameters type
*/
ArrayType *arrayType = ArrayType::get(eleType,
livein.size());
AllocaInst *trueArg = new AllocaInst(arrayType, ""); //true argment for actual (the split one) function call
trueArg->insertBefore(brInst);
//trueArg->setAlignment(8);
//trueArg->dump();
for (unsigned i = 0; i < livein.size(); i++) {
Value *val = livein[i];
CastInst * castVal;
if (val->getType()->isIntegerTy()) {
castVal = new SExtInst(val, eleType, val->getName() + "_arg");
} else if (val->getType()->isPointerTy()) {
castVal = new PtrToIntInst(val, eleType, val->getName() + "_arg");
} else if (val->getType()->isFloatingPointTy()) {
if (val->getType()->isFloatTy()) {
error("floatTypeSuck");
}
castVal = new BitCastInst(val, eleType, val->getName() + "_arg");
} else {
error("what's the hell of the type");
}
castVal->insertBefore(brInst);
//get the element ptr
ConstantInt* idx = ConstantInt::get(Type::getInt64Ty(*context),
(uint64_t) i);
//GetElementPtrInst* ele_addr = GetElementPtrInst::Create(trueArg, idx,""); //use this cannot get the right type!
vector<Value *> arg;
arg.push_back(ConstantInt::get(Type::getInt64Ty(*context), 0));
arg.push_back(idx);
GetElementPtrInst* ele_addr = GetElementPtrInst::Create(trueArg,
arg.begin(), arg.end(), "");
ele_addr->insertBefore(brInst);
//ele_addr->getType()->dump();
StoreInst * storeVal = new StoreInst(castVal, ele_addr);
storeVal->insertBefore(brInst);
// vector<Value *> showArg;
// showArg.push_back(castVal);
// Function *show = module->getFunction("showValue");
// CallInst *callShow = CallInst::Create(show, showArg.begin(), showArg.end());
// callShow->insertBefore(brInst);
}
Function *init = module->getFunction("sync_init");
vector<Value *> args;
CallInst *callInit = CallInst::Create(init, args.begin(), args.end());
callInit->insertBefore(brInst);
/*
* call functions
*/
Function *delegate = module->getFunction("sync_delegate");
for (int i = 0; i < MAX_THREAD; i++) {
Function *func = allFunc[i];
vector<Value*> args;
args.push_back(ConstantInt::get(Type::getInt32Ty(*context),
(uint64_t) i)); //tid
args.push_back(func); //the function pointer
PointerType * finalType = PointerType::get(eleType, 0);
//const Type * finalType = Type::getInt8PtrTy(*context); //debug
BitCastInst * finalArg = new BitCastInst(trueArg, finalType);
finalArg->insertBefore(brInst);
args.push_back(finalArg); //true arg that will be call by func
CallInst * callfunc = CallInst::Create(delegate, args.begin(),
args.end());
// vector<Value *> targs;
// targs.push_back(finalArg);
// CallInst * callfunc = CallInst::Create(allFunc[i], targs.begin(), targs.end());
callfunc->insertBefore(brInst);
}
/*
* join them back
*/
Function *join = module->getFunction("sync_join");
CallInst *callJoin = CallInst::Create(join);
callJoin->insertBefore(brInst);
//replaceBlock->dump(); //check if the new block is correct
// //read back from memory
//
// for (unsigned i = 0; i < livein.size(); i++) {
// Value *val = livein[i];
//
// ConstantInt* idx = ConstantInt::get(Type::getInt64Ty(*context),
// (uint64_t) i);
// GetElementPtrInst* ele_addr = GetElementPtrInst::Create(trueArg, idx,
// ""); //get the element ptr
//
// Load * storeVal = new StoreInst(castVal, ele_addr);
// storeVal->insertBefore(brInst);
// }
}
void DSWP::loopSplit(Loop *L) {
cout << "Loop split" << endl;
// for (Loop::block_iterator bi = L->getBlocks().begin(); bi != L->getBlocks().end(); bi++) {
// BasicBlock *BB = *bi;
// for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
// Instruction *inst = &(*ii);
// }
// }
//check for each partition, find relevant blocks, set could auto deduplicate
for (int i = 0; i < MAX_THREAD; i++) {
cout << "create function for thread " + itoa(i) << endl;
//create function body to each thread
Function *curFunc = allFunc[i];
//each partition contain several scc
map<Instruction *, bool> relinst;
set<BasicBlock *> relbb;
// cout << part[i].size() << endl;
//relbb.insert(header);
/*
* analysis the dependent blocks
*/
for (vector<int>::iterator ii = part[i].begin(); ii != part[i].end(); ii++) {
int scc = *ii;
for (vector<Instruction *>::iterator iii = InstInSCC[scc].begin(); iii
!= InstInSCC[scc].end(); iii++) {
Instruction *inst = *iii;
//relinst[inst] = true;
relbb.insert(inst->getParent());
//add blocks which the instruction dependent on
for (vector<Edge>::iterator ei = rev[inst]->begin(); ei
!= rev[inst]->end(); ei++) {
Instruction *dep = ei->v;
//relinst[dep] = true;
relbb.insert(dep->getParent());
//cout << dep->getParent()->getNameStr() << endl;
}
}
}
// cout << "depend block: " << relbb.size() << " " << "depend inst: " << relinst.size() << endl;
// cout << "header: " << header->getNameStr() << endl;
// //check consistence of the blocks
// for (set<BasicBlock *>::iterator bi = relbb.begin(); bi != relbb.end(); bi++) {
// BasicBlock *BB = *bi;
// cout << BB->getNameStr() << "\t";
// }
// cout << endl;
// //check consitence of the instructions
// for (map<Instruction *, bool>::iterator mi = relinst.begin(); mi != relinst.end(); mi++) {
// cout << dname[mi->first] << "\t";
// }
// cout << endl;
map<BasicBlock *, BasicBlock *> BBMap; //map the old block to new block
if (relbb.size() == 0) {
error("has size 0");
}
/*
* Create the new blocks to the new function, including an entry and exit
*/
BasicBlock * newEntry = BasicBlock::Create(*context, "new-entry",
curFunc);
BasicBlock * newExit =
BasicBlock::Create(*context, "new-exit", curFunc);
//copy the basicblock and modify the control flow
for (set<BasicBlock *>::iterator bi = relbb.begin(); bi != relbb.end(); bi++) {
BasicBlock *BB = *bi;
BasicBlock *NBB = BasicBlock::Create(*context, BB->getNameStr()
+ "_" + itoa(i), curFunc, newExit);
//BranchInst *term = BranchInst::Create(NBB, NBB);
BBMap[BB] = NBB;
}
//curFunc->dump();
//continue;
/*
* insert the control flow and normal instructions
*/
if (BBMap[header] == NULL) {
error("this must be a error early in dependency analysis stage");
}
BranchInst * newToHeader = BranchInst::Create(BBMap[header], newEntry); //pointer to the header so loop can be executed
//BranchInst * newToHeader = BranchInst::Create(newExit, newEntry); //pointer to the header so loop can be executed
ReturnInst * newRet = ReturnInst::Create(*context,
Constant::getNullValue(Type::getInt8PtrTy(*context)), newExit); //return null
//continue;
//curFunc->dump();
for (set<BasicBlock *>::iterator bi = relbb.begin(); bi != relbb.end(); bi++) {
BasicBlock *BB = *bi;
BasicBlock *NBB = BBMap[BB];
for (BasicBlock::iterator ii = BB->begin(); ii != BB->end(); ii++) {
Instruction * inst = ii;
if (assigned[sccId[inst]] != i && !isa<TerminatorInst> (inst)) //TODO I NEED TO CHECK THIS BACK
continue;
Instruction *newInst = inst->clone();
if (inst->hasName()) {
newInst->setName(inst->getName() + "_" + itoa(i));
}
if (isa<TerminatorInst> (newInst)) {
for (unsigned j = 0; j < newInst->getNumOperands(); j++) {
Value *op = newInst->getOperand(j);
if (BasicBlock * oldBB = dyn_cast<BasicBlock>(op)) {
BasicBlock * newBB = BBMap[oldBB];
if (oldBB == L->getExitBlock()) {
newBB = newExit;
} else if (!L->contains(oldBB)) { //so it is a block outside the loop
//cout << oldBB->getNameStr() << endl;
continue;
}
//cout << newBB->getNameStr() << endl;
while (newBB == NULL) {
//find the nearest post-dominator (TODO not sure it is correct)+6
oldBB = pre[oldBB];
newBB = BBMap[oldBB];
}
//replace the target block
newInst->setOperand(j, newBB);
//newInst->dump();
//cout << newBB->getNameStr() << endl;
//TODO check if there are two branch, one branch is not in the partition, then what the branch
}
}
//oldToNew[inst] = newInst; //should not use
}
instMap[i][inst] = newInst;
newInstAssigned[newInst] = i;
newToOld[newInst] = inst;
//newInst->dump();
NBB->getInstList().push_back(newInst);
}// for inst
}// for BB
/*
* Insert load instruction to load argument, (replace the live in variables)
*/
Function::ArgumentListType &arglist = curFunc->getArgumentList();
if (arglist.size() != 1) {
error("argument size error!");
}
Argument *args = arglist.begin(); //the function only have one argmument
Function *showPlace = module->getFunction("showPlace");
vector<Value *> placeArg;
CallInst *inHeader = CallInst::Create(showPlace, placeArg.begin(), placeArg.end());
inHeader->insertBefore(newToHeader);
BitCastInst *castArgs = new BitCastInst(args, PointerType::get(
Type::getInt64Ty(*context), 0));
castArgs->insertBefore(newToHeader);
for (unsigned j = 0; j < livein.size(); j++) {
cout << livein[j]->getNameStr() << endl;
ConstantInt* idx = ConstantInt::get(Type::getInt64Ty(*context),
(uint64_t) j);
GetElementPtrInst* ele_addr = GetElementPtrInst::Create(castArgs, idx, ""); //get the element ptr
ele_addr->insertBefore(newToHeader);
LoadInst * ele_val = new LoadInst(ele_addr);
ele_val->setAlignment(8);
ele_val->setName(livein[j]->getNameStr() + "_val");
ele_val->insertBefore(newToHeader);
// BitCastInst *addcast = new BitCastInst(ele_addr, Type::getInt8PtrTy(*context));
// addcast->insertBefore(newToHeader);
// vector<Value *> showArg2;
// showArg2.push_back(addcast);
// Function *showptr = module->getFunction("showPtr");
// CallInst *callShowptr = CallInst::Create(showptr, showArg2.begin(), showArg2.end());
// callShowptr->insertBefore(newToHeader);
//
vector<Value *> showArg;
showArg.push_back(ele_val);
Function *show = module->getFunction("showValue");
CallInst *callShow = CallInst::Create(show, showArg.begin(), showArg.end());
callShow->insertBefore(newToHeader);
Value *val = livein[j];
CastInst *ele_cast;
if (val->getType()->isIntegerTy()) {
ele_cast = new TruncInst(ele_val, val->getType());
} else if (val->getType()->isPointerTy()) {
ele_cast = new TruncInst(ele_val, Type::getInt32Ty(*context));
ele_cast->insertBefore(newToHeader);
ele_cast = new IntToPtrInst(ele_val, val->getType());
} else if (val->getType()->isFloatingPointTy()) {
if (val->getType()->isFloatTy())
error("float type suck");
ele_cast = new BitCastInst(ele_val, val->getType());
} else {
error("what's the hell of the type");
//ele_cast = new BitCastInst(ele_val, val->getType());
}
ele_cast->insertBefore(newToHeader);
instMap[i][val] = ele_cast;
}
/*
* Replace the use of intruction def in the function (reg dep should be finshied in insert syn
*/
for (inst_iterator ii = inst_begin(curFunc); ii != inst_end(curFunc); ii++) {
Instruction *inst = &(*ii);
for (unsigned j = 0; j < inst->getNumOperands(); j++) {
Value *op = inst->getOperand(j);
if (isa<BasicBlock>(op))
continue;
if (Value * newArg = instMap[i][op]) {
//cout << "Asdfa" << endl;
inst->setOperand(j, newArg);
}
// else if (oldToNew[op]){
// //inst->dump();
// inst->setOperand(j, oldToNew[op]); //set a new variable but is in other thread, however, now we don't have ref to original loop
// error("dswp4, here should be careful, not neccessary a error");
// }
}
}
//curFunc->dump();
}
/*
* Insert Syn to gurantee
*/
//cout << "test_now" << endl;
//insert store instruction (store register value to memory), now I insert them into the beginning of the function
// Instruction *allocPos = func->getEntryBlock().getTerminator();
//
// vector<StoreInst *> stores;
// for (set<Value *>::iterator vi = defin.begin(); vi != defin.end(); vi++) { //TODO: is defin enough
// Value *val = *vi;
// AllocaInst * arg = new AllocaInst(val->getType(), 0, val->getNameStr() + "_ptr", allocPos);
// varToMem[val] = arg;
// }
}
void DSWP::clearup(Loop *L) {
/*
* move the produce instruction which been inserted after the branch in front of it
*/
for (int i = 0; i < MAX_THREAD; i++) {
for (Function::iterator bi = allFunc[i]->begin(); bi != allFunc[i]->end(); bi++) {
BasicBlock * bb = bi;
TerminatorInst *term = NULL;
for (BasicBlock::iterator ii = bb->begin(); ii != bb->end(); ii++) {
Instruction *inst = ii;
if (isa<TerminatorInst>(inst)) {
term = dyn_cast<TerminatorInst>(inst);
break;
}
}
if (term == NULL) {
error("term cannot be null");
}
while (1) {
Instruction *last = &bb->getInstList().back();
if (isa<TerminatorInst>(last))
break;
last->moveBefore(term);
}
}
}
cout << "begin to delete loop" << endl;
for (Loop::block_iterator bi = L->block_begin(), bi2; bi != L->block_end(); bi = bi2) {
bi2 = bi;
bi2++;
BasicBlock * BB = *bi;
for (BasicBlock::iterator ii = BB->begin(), ii2; ii != BB->end(); ii
= ii2) {
ii2 = ii;
ii2++;
Instruction *inst = ii;
inst->eraseFromParent();
}
BB->eraseFromParent();
}
for (int i = 0; i < MAX_THREAD; i++) {
// allFunc[i]->dump();
}
cout << "other stuff" << endl;
pdg.clear();
rev.clear();
dag.clear();
allEdges.clear();
InstInSCC.clear();
pre.clear();
sccId.clear();
used.clear();
list.clear();
assigned.clear();
for (int i = 0; i < MAX_THREAD; i++) {
part[i].clear();
instMap[i].clear();
}
sccLatency.clear();
newToOld.clear();
newInstAssigned.clear();
allFunc.clear();
livein.clear();
defin.clear();
liveout.clear();
dname.clear();
//cout << Type::getInt8PtrTy(*context, 0)->
}
void DSWP::getLiveinfo(Loop * L) {
defin.clear();
livein.clear();
liveout.clear();
//currently I don't want to use standard liveness analysis
for (Loop::block_iterator bi = L->getBlocks().begin(); bi
!= L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
Instruction *inst = &(*ui);
if (util.hasNewDef(inst)) {
defin.push_back(inst);
}
for (Instruction::use_iterator oi = inst->use_begin(); oi
!= inst->use_end(); oi++) {
User *use = *oi;
if (Instruction *ins = dyn_cast<Instruction>(use)) {
if (!L->contains(ins)) {
error("loop defin exist outside the loop");
}
} else {
error("tell me how could not");
}
}
}
}
//make all the use in the loop, but not defin in it, as live in variable
for (Loop::block_iterator bi = L->getBlocks().begin(); bi
!= L->getBlocks().end(); bi++) {
BasicBlock *BB = *bi;
for (BasicBlock::iterator ui = BB->begin(); ui != BB->end(); ui++) {
Instruction *inst = &(*ui);
for (Instruction::op_iterator oi = inst->op_begin(); oi
!= inst->op_end(); oi++) {
Value *op = *oi;
if (isa<Instruction> (op) || isa<Argument> (op)) {
if (find(defin.begin(), defin.end(), op) == defin.end()) { //variable not defin in loop
if (find(livein.begin(), livein.end(), op) == livein.end()) //deduplicate
livein.push_back(op);
}
}
}
}
}
//NOW I DIDN'T SEE WHY WE NEED LIVE OUT
// //so basically I add variables used in loop but not been declared in loop as live variable
//
// //I think we could assume liveout = livein + defin at first, especially I havn't understand the use of liveout
// liveout = livein;
// liveout.insert(defin.begin(), defin.end());
//
// //now we can delete those in liveout but is not really live outside the loop
// LivenessAnalysis *live = &getAnalysis<LivenessAnalysis>();
// BasicBlock *exit = L->getExitBlock();
//
// for (set<Value *>::iterator it = liveout.begin(), it2; it != liveout.end(); it = it2) {
// it2 = it; it2 ++;
// if (!live->isVaribleLiveIn(*it, exit)) { //livein in the exit is the liveout of the loop
// liveout.erase(it);
// }
// }
}
| C++ |
/*
* DFAValue.cpp
*
* Created on: Jan 29, 2011
* Author: Fuyao Zhao, Mark Hahnenberg
*/
#include "DFAValue.h"
#include <iostream>
using namespace std;
DFAValue::DFAValue() {
}
DFAValue::DFAValue(int n) {
bits = vector<bool>(n);
clear();
}
void DFAValue::set(int i) {
bits[i] = 1;
}
void DFAValue::clear(int i) {
bits[i] = 0;
}
bool DFAValue::get(int i) const {
return bits[i];
}
void DFAValue::clear() {
for (unsigned i = 0; i < bits.size(); i++)
clear(i);
}
void DFAValue::set() {
for (unsigned i = 0; i < bits.size(); i++)
set(i);
}
DFAValue DFAValue::operator | (const DFAValue &y) const {
DFAValue res = *this;
for (unsigned i = 0; i < y.bits.size(); i++) {
res.bits[i] = y.bits[i] | this->bits[i];
}
return res;
}
DFAValue DFAValue::operator & (const DFAValue &y) const {
DFAValue res = *this;
for (unsigned i = 0; i < y.bits.size(); i++) {
res.bits[i] = y.bits[i] & this->bits[i];
//if (y.get(i) && this->get(i))
// res.set(i);
}
return res;
}
bool DFAValue::operator == (const DFAValue &y) const {
for (unsigned i = 0; i < y.bits.size(); i++) {
if (get(i) != y.get(i) )
return false;
}
return true;
}
bool DFAValue::operator != (const DFAValue &y) const {
return !(*this == y);
}
void DFAValue::show() {
cout << bits.size() << ": ";
for (unsigned i = 0; i < bits.size(); i++) {
cout << (bits[i] ? 1 : 0);
}
cout << endl;
}
| C++ |
#if !defined(AFX_GONRYUNBATTLEPRACTICE_H__F18A9CE1_E566_49AB_A524_3B8724AE776B__INCLUDED_)
#define AFX_GONRYUNBATTLEPRACTICE_H__F18A9CE1_E566_49AB_A524_3B8724AE776B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
PCB_EFF_NONE,
PCB_EFF_READY,
PCB_EFF_WIN,
PCB_EFF_DRAW,
PCB_EFF_DEFEAT,
};
enum
{
PCB_NONE,
PCB_SUGGEST,
PCB_BATTING,
PCB_READY,
PCB_COUNTDOWN,
PCB_START,
PCB_END,
PCB_MAX
};
enum enumGonryunBattleErrorCode
{
success = 1,
overflow_oneday_use_count = 2,
missmatch_user_level = 3,
not_enoughf_nak = 4,
busy_GonryunBattlePractice = 5,
overflow_user_number = 6,
gonryun_NotUse = 7,
differLevel = 8,
busy_Suggest = 9,
unknown = 10,
Weight_Over = 11,
NotEnough_InventorySpace = 12,
gonryun_Lest_UseCount = 13,
};
class CGonryunBattlePractice
{
public:
BOOL m_bshow;
DWORD m_dwFPS;
DWORD m_dwTimes;
short int m_ieffectMode;
short int m_ibattleMode;
short int m_ibattleinfoMode;
short int m_ieffectIndex;
int m_arrEffIdx;
int m_iLevelDiffer;
int m_myTradeSEtemp;
int m_otherTradeSEtemp;
int m_imyTradetemp[MAX_TRADE_SIZE];
int m_iotherTradetemp[MAX_TRADE_SIZE];
int m_iroyalty;
int m_ibattingRoyalty;
item_t m_itradeItemtemp[MAX_TRADE_SIZE];
float m_fAngle;
struct LeaderInfo {
int pcidx;
char Name[NAMESTRING+1];
};
enum enumBattingErrorCode{
ERROR_None = 0,
ERROR_Weight_Over,
ERROR_NotEnough_InventorySpace,
ERROR_NotEnough_Nake,
ERROR_Over_BattingNake,
ERROR_InvalideUser,
};
struct LeaderInfo m_leader;
public:
CGonryunBattlePractice();
virtual ~CGonryunBattlePractice();
public :
void RecvDanBattle();
public :
void RecvErrorCode();
void RecvRequesterList();
void RecvBattleInfo();
void RecvBattleResult();
void RecvBattleStart();
void RecvSuggestResult();
void RecvBattleReward();
void RecvRefreshData();
void RecvGonryunFieldOut();
public :
void SendRequestBattle();
void SendSetStatus(BYTE bStatus);
void SendSuggestBattle(int danIdx,LPSTR DanName);
void SendSuggestResult(BYTE bResult);
void SendChangeBattleMap();
void SendInitChao();
void SendCancelRequest();
void SendGonryunBan();
void SendGonryunStart(int minLevel,int maxLevel);
void SendMessagePosition(float pos_x,float pos_y, float pos_z);
void SendBanBatting(void);
void SendCancelBatting(void);
void SendDanTestMode(int mode);
void SendFailItemAdd(void);
void RecvGonryunEnd();
void RecvGonryunDeleteUser();
void RecvOtherMyinfo();
void RecvMyinfo();
void RequestBattleBatting(char *pUser);
void RequestBattleGenerate(char *pUser);
void RecvBattleGenerate();
void RecvBattleBatting();
void SendSuggestResultGenerate(BYTE bresult);
void RecvRequestResultBatting();
void RecvRequestResultGenerate();
void RecvGonryunState();
void RecvGonryunRewordField();
void RecvGonryunBattleInfo();
void RecvGonryunBattigReject();
void RecvGonryunGenerateReject();
void RecvBattleMsg();
void RecvRequestGonryunResult();
void RecvBattleNake();
void RecvBattleAddUser(void);
void RecvDeleteUser(void);
void ProcessGonryunEffect();
void RecvProcessEffect();
void RecvBattleOpen(void);
void GTH_SendMessage_CheatGonryunCode(short int message);
};
#endif
| C++ |
#include "../global_def.h"
CGonryunBattlePractice::CGonryunBattlePractice()
{
m_ibattleMode = PCB_NONE;
m_ieffectMode = PCB_EFF_NONE;
m_ieffectIndex = 0;
m_dwTimes = 0;
m_dwFPS = 0.5f;
m_arrEffIdx = 0;
m_bshow = FALSE;
m_ibattleinfoMode = PCB_NONE;
m_fAngle = 0.0f;
m_fAngle=timeGetTime();
m_iLevelDiffer = 0;
m_leader.pcidx = -1;
m_leader.Name[0] = NULL;
m_iroyalty = 0;
}
CGonryunBattlePractice::~CGonryunBattlePractice()
{
}
void CGonryunBattlePractice::SendCancelRequest()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_GET_CANCEL);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendBanBatting(void)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_BAN_BATTING);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendCancelBatting(void)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_CANCEL_BATTING);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::RecvDanBattle()
{
BYTE bCommand;
bCommand = MSG_ReadByte();
switch (bCommand)
{
case BATTLE_PRACTICE_GET_OTHERLISTINFO : RecvRequesterList(); break;
case BATTLE_PRACTICE_END : RecvGonryunEnd(); break;
case BATTLE_PRACTICE_SEND_OTHERMYINFO: RecvOtherMyinfo(); break;
case BATTLE_PRACTICE_REQUEST_DELETE_USER : RecvGonryunDeleteUser(); break;
case BATTLE_PRACTICE_GET_MYINFO: RecvMyinfo(); break;
case BATTEL_PRACTICE_REQUEST_BATTELBATTING: RecvBattleBatting(); break;
case BATTLE_PRACTICE_REQUEST_BATTELGENERATE: RecvBattleGenerate(); break;
case BATTLE_PRACTICE_BATTING_RESULT: RecvRequestResultBatting(); break;
case BATTLE_PRACTICE_GENERATE_RESULT: RecvRequestResultGenerate(); break;
case BATTLE_PRACTICE_STATE: RecvGonryunState(); break;
case BATTLE_PRACTICE_RWORDFIELD: RecvGonryunRewordField(); break;
case BATTLE_PRACTICE_BATTINGTRADE_REQUEST: GTH_ProcessMessage_PCTrade_RequestBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_RESULT: GTH_ProcessMessage_PCTrade_AdmitBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_REJECT: GTH_ProcessMessage_PCTrade_RejectBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_OK: GTH_ProcessMessage_PCTrade_OkBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_CANCEL: GTH_ProcessMessage_PCTrade_CancelBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_EXIT : GTH_ProcessMessage_PCTrade_ExitBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_ITEM : GTH_ProcessMessage_PCTrade_ItemBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_CONFIRM : GTH_ProcessMessage_PCTrade_ConfirmBatting(); break;
case BATTLE_PRACTICE_BATTINGTRADE_SE : GTH_ProcessMessage_PCTrade_SEBatting(); break;
case BATTLE_PRACIICE_EFFECT_MODE: RecvProcessEffect(); break;
case BATTEL_PRACTICE_INFO: RecvGonryunBattleInfo(); break;
case BATTLE_PRACTICE_FIELDOUT: RecvGonryunFieldOut(); break;
case BATTLE_PRACTICE_BATTING_REJECT: RecvGonryunBattigReject(); break;
case BATTLE_PRACTICE_GENERATE_REJECT: RecvGonryunGenerateReject(); break;
case BATTLE_PRACTICE_MSG: RecvBattleMsg(); break;
case BATTEL_PRACTICE_NAKE_RESULT : RecvBattleNake(); break;
case BATTLE_PRACTICE_MYINFO_TOUSER: RecvBattleAddUser(); break;
case BATTLE_PRACTICE_DELETE_USER: RecvDeleteUser(); break;
case BATTEL_PRACTICE_RESULT: RecvRequestGonryunResult(); break;
case BATTLE_PRACTICE_OPEN: RecvBattleOpen(); break;
}
}
void CGonryunBattlePractice::RecvBattleOpen(void)
{
m_iroyalty = MSG_ReadLong();
m_ibattingRoyalty = MSG_ReadLong();
}
void CGonryunBattlePractice::RecvDeleteUser(void)
{
char czUserName[NAMESTRING+1];
strncpy(czUserName,MSG_ReadString(),NAMESTRING);
czUserName[NAMESTRING] = NULL;
for(int i=0; i < MAX_STANDBYCOUNT; i++)
{
int compare = strncmp(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],czUserName,NAMESTRING);
if(0 == compare)
{
memset(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i], NULL , sizeof (char) * NAMESTRING );
g_ifMng->m_pgonryunBattlePractice->m_textCtl[IT_GUILD_WAR_WIN_STANDBY_LIST1_TEXT+i]->SetText("");
g_ifMng->m_pgonryunBattlePractice->m_textCtl[IT_GUILD_WAR_WIN_STANDBY_LIST1_TEXT+i]->SetColor(0xff808080);
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].win = 0;
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].draw = 0;
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].lose = 0;
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].level= 0;
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount--;
break;
}
}
}
void CGonryunBattlePractice::RecvBattleAddUser(void)
{
char czUserName[NAMESTRING+1];
strncpy(czUserName,MSG_ReadString(),NAMESTRING);
czUserName[NAMESTRING]=NULL;
for(int i=0; i < MAX_STANDBYCOUNT; i++)
{
int compare = strcmp(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],"");
if(0 == compare)
{
strcpy(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],czUserName);
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].win=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].draw=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].lose=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].level=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount++;
break;
}
}
}
void CGonryunBattlePractice::RecvBattleNake()
{
g_cgv.myCharacterInfo->curChargeSE=MSG_ReadLong();
}
void CGonryunBattlePractice::RecvRequestGonryunResult()
{
char cz_temp[256];
char cz_name[NAMESTRING+1];
cz_name[0]=NULL;
int result=MSG_ReadByte();
strncpy(cz_name,MSG_ReadString(),NAMESTRING);
cz_name[NAMESTRING]=NULL;
switch(result) {
case 0:
break;
case 1:
sprintf( cz_temp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,118), cz_name );
g_ifMng->AddSysMessage( cz_temp, D3DCOLOR_ARGB(255, 255, 125, 100) );
break;
case 2:
break;
}
}
void CGonryunBattlePractice::RecvGonryunBattigReject()
{
if( g_ifMng->m_msgType == IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_BATTING )
g_ifMng->ExitMessage();
}
void CGonryunBattlePractice::RecvGonryunGenerateReject()
{
if( g_ifMng->m_msgType == IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_GENERATE )
g_ifMng->ExitMessage();
}
void CGonryunBattlePractice::RecvGonryunFieldOut()
{
g_ifMng->AddSysMessage( g_LPACK.GetMessage(0, 914), GTHCOLOR_QUESTMESSAGE );
}
void CGonryunBattlePractice::RecvErrorCode()
{
BYTE eCode = MSG_ReadByte();
BYTE eType = MSG_ReadByte();
}
void CGonryunBattlePractice::RecvRequesterList()
{
g_ifMng->m_pgonryunBattlePractice->ClearStandbyList();
BYTE bSize=MSG_ReadByte();
m_iLevelDiffer = MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount = bSize;
char czUserName[NAMESTRING+1];
strncpy(czUserName,MSG_ReadString(),NAMESTRING);
czUserName[NAMESTRING]=NULL;
int bisLeader=MSG_ReadShort();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].win=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].draw=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].lose=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].level=MSG_ReadByte();
g_ifMng->m_chatWin->Enable( FALSE );
g_ifMng->m_pgonryunBattlePractice->Enable();
g_ifMng->SetFocus( g_ifMng->m_pgonryunBattlePractice);
strncpy(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[0],czUserName,NAMESTRING);
g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[0][NAMESTRING] = NULL;
strncpy(g_ifMng->m_pgonryunBattlePractice->m_szATeamList,czUserName,NAMESTRING);
g_ifMng->m_pgonryunBattlePractice->m_szATeamList[NAMESTRING] = NULL;
g_ifMng->m_pgonryunBattlePractice->m_RegAteamIdx=0;
char UserName[NAMESTRING+1];
for (int i=1; i < bSize; i++)
{
strncpy(UserName,MSG_ReadString(),NAMESTRING);
UserName[NAMESTRING] = NULL;
strncpy(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i], UserName,NAMESTRING);
g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i][NAMESTRING] = NULL;
short int bisleader=MSG_ReadShort();
if( 0 == strcmp(g_cgv.syncCharacter[0].name,UserName))
{
g_ifMng->m_pgonryunBattlePractice->m_MyTextIdxinStandby=i;
}
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].win=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].draw=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].lose=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].level=MSG_ReadByte();
}
if ( bisLeader == 1)
{
if(0 == strncmp(g_cgv.syncCharacter[0].name,czUserName,NAMESTRING))
{
g_ifMng->m_pgonryunBattlePractice->m_isLeader = TRUE;
g_ifMng->m_pgonryunBattlePractice->m_MyTextIdxinStandby=0;
}
}
}
void CGonryunBattlePractice::RecvGonryunEnd()
{
if(0==g_ifMng->m_pgonryunBattlePractice->State()) return;
g_ifMng->m_pgonryunBattlePractice->Enable(FALSE);
g_ifMng->m_pgonryunBattlePractice->ClearStandbyList();
m_iLevelDiffer = 0;
}
void CGonryunBattlePractice::RecvGonryunDeleteUser()
{
char czUser[NAMESTRING];
strncpy(czUser,MSG_ReadString(),NAMESTRING);
czUser[NAMESTRING-1]=NULL;
for (int i = 0; i < MAX_STANDBYCOUNT; i ++)
{
int compare=strcmp(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],czUser);
if(0==compare)
{
memset(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i], NULL , sizeof (char) * NAMESTRING );
g_ifMng->m_pgonryunBattlePractice->m_textCtl[IT_GUILD_WAR_WIN_STANDBY_LIST1_TEXT+i]->SetText("");
g_ifMng->m_pgonryunBattlePractice->m_textCtl[IT_GUILD_WAR_WIN_STANDBY_LIST1_TEXT+i]->SetColor(0xff808080);
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount--;
break;
}
}
}
void CGonryunBattlePractice::RecvOtherMyinfo()
{
char czUserName[NAMESTRING];
strncpy(czUserName,MSG_ReadString(),NAMESTRING);
czUserName[NAMESTRING-1]=NULL;
int bisLeader=MSG_ReadShort();
for(int i=0; i < MAX_STANDBYCOUNT; i++)
{
int compare=strcmp(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],"");
if(0==compare)
{
strcpy(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[i],czUserName);
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].win=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].draw=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].lose=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[i].level=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount++;
break;
}
}
}
void CGonryunBattlePractice::RecvMyinfo()
{
char czUserName[NAMESTRING];
strncpy(czUserName,MSG_ReadString(),NAMESTRING);
czUserName[NAMESTRING-1]=NULL;
g_ifMng->m_pgonryunBattlePractice->ClearStandbyList();
int bisLeader=MSG_ReadShort();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].win=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].draw=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].lose=MSG_ReadByte();
g_ifMng->m_pgonryunBattlePractice->m_arrayUserInfo[0].level=MSG_ReadByte();
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_pgonryunBattlePractice->Enable();
g_ifMng->SetFocus( g_ifMng->m_pgonryunBattlePractice);
strncpy(g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[0],czUserName,NAMESTRING);
g_ifMng->m_pgonryunBattlePractice->m_MyTextIdxinStandby=0;
g_ifMng->m_pgonryunBattlePractice->m_currentUserCount++;
g_ifMng->m_pgonryunBattlePractice->m_isLeader=(BOOL)bisLeader;
if(bisLeader==TRUE)
{
strncpy(g_ifMng->m_pgonryunBattlePractice->m_szATeamList,czUserName,NAMESTRING);
g_ifMng->m_pgonryunBattlePractice->m_RegAteamIdx=0;
}
}
void CGonryunBattlePractice::RequestBattleBatting(char *pUser)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTEL_PRACTICE_REQUEST_BATTELBATTING);
MSG_WriteString(&netMessage, pUser);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::RequestBattleGenerate(char *pUser)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE);
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_REQUEST_BATTELGENERATE );
MSG_WriteString(&netMessage, pUser);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::RecvBattleBatting()
{
char cz_string[256];
sprintf(cz_string,g_LPACK.GetMessage(9,112),g_LPACK.GetMessage(9,128));
g_ifMng->SetMessage( g_LPACK.GetMessage(0,322),cz_string, MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_BATTING, 10000.0f );
}
void CGonryunBattlePractice::RecvBattleGenerate()
{
char cz_string[256];
m_leader.pcidx = MSG_ReadLong();
m_leader.Name[0]=NULL;
strncpy(m_leader.Name,MSG_ReadString(),NAMESTRING);
m_leader.Name[NAMESTRING-1] = NULL;
sprintf(cz_string,g_LPACK.GetMessage(9,197),m_leader.Name);
g_ifMng->SetMessage( g_LPACK.GetMessage(0,322),cz_string, MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_GENERATE, 10000.0f );
}
void CGonryunBattlePractice::SendSuggestResultGenerate(BYTE bresult)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_GENERATE_RESULT);
if(g_ifMng->m_pgonryunBattlePractice->m_isLeader!=TRUE){
MSG_WriteLong(&netMessage, m_leader.pcidx);
MSG_WriteString(&netMessage,m_leader.Name);
}
else{
MSG_WriteString(&netMessage,g_ifMng->m_pgonryunBattlePractice->m_szStandbyList[g_ifMng->m_pgonryunBattlePractice->m_selectStandbyIdx]);
}
MSG_WriteByte(&netMessage, bresult);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::RecvRequestResultBatting()
{
BYTE type = MSG_ReadByte();
if( g_ifMng->m_msgType == IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_BATTING )
g_ifMng->ExitMessage();
switch ( type )
{
case 0:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9,134), D3DCOLOR_ARGB(255, 255, 125, 100) );
break;
case 1:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9,135), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_pgonryunBattlePractice->ClearStandbyList();
g_ifMng->m_pgonryunBattlePractice->Enable(false);
g_ifMng->m_pgonryunBattlePractice->ClearRegTeams();
break;
case 2:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(0, 36), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_pgonryunBattlePractice->Enable(FALSE);
g_ifMng->m_pgonryunBattlePractice->ClearRegTeams();
break;
}
}
void CGonryunBattlePractice::RecvRequestResultGenerate()
{
BYTE type = MSG_ReadByte();
if( g_ifMng->m_msgType == IF_MESSAGE_GONRYUN_BATTLE_PRACTICE_GENERATE )
g_ifMng->ExitMessage();
switch ( type )
{
case 0:
break;
case 1:
g_cgv.myCharacterInfo->m_bbattleMode=TRUE;
g_ifMng->m_pgonryunBattlePractice->m_bbattleMode=TRUE;
break;
case 2:
g_ifMng->m_pgonryunBattlePractice->Enable(FALSE);
g_ifMng->m_pgonryunBattlePractice->ClearRegTeams();
break;
}
}
void CGonryunBattlePractice::RecvGonryunState()
{
m_ibattleMode=MSG_ReadShort();
switch(m_ibattleMode) {
case PCB_BATTING:
g_input->MouseEnable(true);
g_input->KeyEnable(true);
g_ifMng->m_pGonryunBattleProgressInfo->Enable(true);
g_ifMng->m_pgonryunBattleBattingwindow->Enable(false);
g_ifMng->m_itemWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_pGonryunBattleProgressInfo );
break;
case PCB_START:
g_input->MouseEnable(true);
g_input->KeyEnable(true);
g_ifMng->m_pGonryunBattleProgressInfo->Enable(true);
g_ifMng->m_pgonryunBattleBattingwindow->Enable(false);
g_ifMng->m_itemWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_pGonryunBattleProgressInfo );
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9, 115), D3DCOLOR_ARGB(255, 255, 125, 100) );
break;
case PCB_END:
g_input->MouseEnable(true);
g_input->KeyEnable(true);
g_ifMng->m_pGonryunBattleProgressInfo->m_RemainTime=0;
g_ifMng->m_pGonryunBattleProgressInfo->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9, 116), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->AddSysMessage( g_LPACK.GetMessage(0, 914), GTHCOLOR_QUESTMESSAGE );
break;
case PCB_NONE:
g_input->MouseEnable(true);
g_input->KeyEnable(true);
g_ifMng->m_pGonryunBattleProgressInfo->m_RemainTime=0;
g_ifMng->m_pGonryunBattleProgressInfo->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
break;
case PCB_READY:
g_input->MouseEnable(false);
g_input->KeyEnable(false);
g_ifMng->AddSysMessage( g_LPACK.GetMessage(0, 913), GTHCOLOR_QUESTMESSAGE );
g_ifMng->m_pgonryunBattlePractice->Enable(false);
g_ifMng->m_pgonryunBattleBattingwindow->Enable(false);
g_ifMng->m_itemWin->Enable(false);
break;
default :
g_ifMng->m_pgonryunBattleBattingwindow->Enable(false);
g_ifMng->m_itemWin->Enable(false);
break;
}
}
void CGonryunBattlePractice::RecvGonryunRewordField()
{
short int rewordtype=MSG_ReadShort();
}
void CGonryunBattlePractice::ProcessGonryunEffect()
{
if(m_ieffectMode == PCB_EFF_NONE) return;
switch(m_ieffectMode) {
case PCB_EFF_READY:
{
if(timeGetTime() - m_dwTimes>900/1)
{
m_bshow=TRUE;
m_ieffectIndex++;
if(m_ieffectIndex>64)
{
m_ieffectMode=PCB_EFF_NONE;
g_input->MouseEnable(true);
g_input->KeyEnable(true);
m_bshow=FALSE;
break;
}
m_dwTimes=timeGetTime();
}
else m_bshow=FALSE;
float fTime=(timeGetTime() - m_fAngle)*0.03f;
m_fAngle=timeGetTime();
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
if( g_camera.m_angles[ YAW ] < 0.0f ) g_camera.m_angles[ YAW ] += 360.0f;
if( g_camera.m_angles[ YAW ] > 360.0f ) g_camera.m_angles[ YAW ] -= 360.0f;
g_camera.m_angles[ YAW ] += fTime;
if(m_bshow==TRUE)
{
if(m_ieffectIndex<=63)
{
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_COUNT ), GTH_SOUND_PLAY_ONCE );
}
else
{
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_READYFIGHT ), GTH_SOUND_PLAY_ONCE );
}
g_input->MouseEnable(false);
g_input->KeyEnable(false);
m_arrEffIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
m_ieffectIndex,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
g_input->MouseEnable(true);
g_input->KeyEnable(true);
m_bshow=FALSE;
}
}
break;
case PCB_EFF_WIN:
if(m_bshow==TRUE)
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
VectorCopy( g_camera.m_angles, myChar->angles );
g_camera.m_angles[YAW] = myChar->angles[YAW] + 180.0f;
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_COUNT ), GTH_SOUND_PLAY_ONCE , myChar->position );
if(m_ieffectIndex!=66) break;
m_arrEffIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
m_ieffectIndex,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
m_ieffectMode=PCB_EFF_NONE;
m_bshow=FALSE;
}
break;
case PCB_EFF_DEFEAT:
if(m_bshow==TRUE)
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
VectorCopy( g_camera.m_angles, myChar->angles );
g_camera.m_angles[YAW] = myChar->angles[YAW] + 180.0f;
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_FAIL ), GTH_SOUND_PLAY_ONCE , myChar->position );
m_arrEffIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
m_ieffectIndex,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
m_ieffectMode=PCB_EFF_NONE;
m_bshow=FALSE;
}
break;
}
}
void CGonryunBattlePractice::RecvProcessEffect()
{
m_ieffectMode=MSG_ReadShort();
switch(m_ieffectMode)
{
case PCB_EFF_READY:
{
m_ieffectIndex=53;
m_bshow=TRUE;
}
break;
case PCB_EFF_WIN:
{
g_ifMng->m_pGonryunBattleProgressInfo->m_RemainTime=0;
g_ifMng->m_pGonryunBattleProgressInfo->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
m_ieffectIndex=66;
m_bshow=TRUE;
}
break;
case PCB_EFF_DEFEAT:
{
g_ifMng->m_pGonryunBattleProgressInfo->m_RemainTime=0;
g_ifMng->m_pGonryunBattleProgressInfo->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
m_ieffectIndex=67;
m_bshow=TRUE;
}
break;
default:
m_ieffectIndex=0;
m_bshow=TRUE;
break;
}
}
void CGonryunBattlePractice::RecvGonryunBattleInfo()
{
g_ifMng->m_pGonryunBattleProgressInfo->m_RemainTime=MSG_ReadLong();
}
void CGonryunBattlePractice::GTH_SendMessage_CheatGonryunCode(short int message)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteLong(&netMessage, message);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendGonryunBan()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_BAN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendGonryunStart(int minLevel,int maxLevel)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_START);
MSG_WriteLong(&netMessage, minLevel);
MSG_WriteLong(&netMessage, maxLevel);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendMessagePosition(float pos_x,float pos_y, float pos_z)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_POSITION);
MSG_WriteFloat(&netMessage,pos_x);
MSG_WriteFloat(&netMessage,pos_y);
MSG_WriteFloat(&netMessage,pos_z);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::SendFailItemAdd(void)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_REQUEST_GONRYUNBATTLEPRACTICE );
MSG_WriteByte(&netMessage, BATTLE_PRACTICE_FAILADDITEM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGonryunBattlePractice::RecvBattleMsg()
{
int reply;
int readValue[3];
char msgBuffer[MAX_PATH];
memset(msgBuffer,0,MAX_PATH);
reply=MSG_ReadLong();
readValue[0]=MSG_ReadLong();
readValue[1]=MSG_ReadLong();
readValue[2]=MSG_ReadLong();
switch (reply)
{
case overflow_oneday_use_count :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 130 ), readValue[0]);
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case missmatch_user_level :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 109 ), readValue[0], readValue[1]);
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case not_enoughf_nak :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 128 ), readValue[0]);
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case busy_GonryunBattlePractice :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 119 ));
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case overflow_user_number :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 110 ));
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case gonryun_NotUse :
sprintf(msgBuffer, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 119 ));
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer );
break;
case differLevel :
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,111), 1, IF_MESSAGE_NONE );
break;
case busy_Suggest:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,534), 1, IF_MESSAGE_NONE );
break;
case unknown:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,535), 1, IF_MESSAGE_NONE );
break;
case Weight_Over:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,583), 1, IF_MESSAGE_NONE );
break;
case NotEnough_InventorySpace:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322),g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,584), 1, IF_MESSAGE_NONE );
break;
case gonryun_Lest_UseCount:
sprintf(msgBuffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,585), readValue[0]);
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), msgBuffer,1, IF_MESSAGE_NONE);
break;
}
}
| C++ |
#include "stdafx.h"
#include "CheckSUm.h"
#include "stdafx.h"
#include "Checksum.h"
void checksum::add(DWORD value)
{
union { DWORD value; BYTE bytes[4]; } data;
data.value = value;
for(UINT i = 0; i < sizeof(data.bytes); i++)
add(data.bytes[i]);
}
void checksum::add(WORD value)
{
union { DWORD value; BYTE bytes[2]; } data;
data.value = value;
for(UINT i = 0; i < sizeof(data.bytes); i++)
add(data.bytes[i]);
}
void checksum::add(BYTE value)
{
BYTE cipher = (value ^ (r >> 8));
r = (cipher + r) * c1 + c2;
sum += cipher;
}
void checksum::add(LPBYTE b, UINT length)
{
for(UINT i = 0; i < length; i++)
add(b[i]);
} | C++ |
#define STRICT
#define _WIN32_WINNT 0x0400
#include <windows.h>
#include <basetsd.h>
#include <tchar.h>
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
#include "game/GolryunBattle/GolryunBattle.h"
itementity_t *g_mouseSelectedItemObject;
Fx_CHARACTER_t *g_mouseSelectedCharacter;
int g_stop = false;
int g_freeMove = 0;
int g_viewSide = 0;
int g_timetype = 0;
int g_volume = 0;
extern int testSyncNum;
HHOOK g_hHook;
char gszInstallFolder[MAX_PATH]="";
LRESULT CALLBACK LowLevelKeyboardProc (INT nCode, WPARAM wParam, LPARAM lParam)
{
KBDLLHOOKSTRUCT *pkbhs = (KBDLLHOOKSTRUCT *) lParam;
BOOL bControlKeyDown = 0;
switch (nCode)
{
case HC_ACTION:
{
bControlKeyDown = GetAsyncKeyState (VK_CONTROL) >> ((sizeof(SHORT) * 8) - 1);
if (pkbhs->vkCode == VK_ESCAPE && bControlKeyDown)
{
return 1;
}
if (pkbhs->vkCode == VK_TAB && pkbhs->flags & LLKHF_ALTDOWN)
{
return 1;
}
if (pkbhs->vkCode == VK_ESCAPE && pkbhs->flags & LLKHF_ALTDOWN)
{
return 1;
}
if( pkbhs->vkCode == VK_LWIN )
{
return 1;
}
if( pkbhs->vkCode == VK_RWIN )
{
return 1;
}
if( pkbhs->vkCode == VK_APPS )
{
return 1;
}
break;
}
default:
break;
}
return CallNextHookEx (g_hHook, nCode, wParam, lParam);
}
BOOL InstallKeyHookProc( HINSTANCE hInstance )
{
g_hHook = SetWindowsHookEx( WH_KEYBOARD_LL , LowLevelKeyboardProc , hInstance , 0 );
if( g_hHook == NULL )
{
return FALSE;
}
return TRUE;
}
#ifdef _TERRA
#include ".\Terra ICT\CTerraCtrl.h"
CTerraCtrl gcTerraCtrl;
#endif
#include "GM(Game Master)\CGMCtrl.h"
CGMCtrl* gcpGMCtrl=NULL;
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR lpszCmdParam, INT )
{
GetCurrentDirectory(MAX_PATH,gszInstallFolder);
if( !InstallKeyHookProc( hInst ) )
SystemParametersInfo( SPI_SCREENSAVERRUNNING , TRUE , NULL , 0 );
#ifdef _AHNLAB_HACKSHIELD
if(FALSE == gcAhnLabHackShieldCtrl.ServiceStart()){
assert(FALSE);
MessageBox(NULL, "HackShield Error","AhnLab's HackShield", MB_OK);
return 0;
}
#endif
g_cgv.isDeveloper = true;
g_cgv.isUpdatePatch = false;
//lucky 2012 Launcher ADD
if( !strstr( lpszCmdParam, "/xhKdu78838J" ) )
{
MessageBox(NULL, "Please run GTH from the launcher GTH.exe","error", MB_OK);
return 0;
}
//end
//lucky 2012 start only 1 GTH client .
HANDLE winmutex = CreateMutex(NULL,FALSE,"Gate to Heavens");
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
MessageBox(NULL, "Gate to Heavens is already started","Notice", MB_OK);
return 0;
}
//end
GTH_Setup_LoadConfig( "gthconfig.cfg" );
g_resCounter = new CResCounter();
g_resCounter->DisableResCounter();
#ifdef _DEBUG
if( strstr( lpszCmdParam, "/rescount" ) )
{
g_resCounter->EnableResCounter();
}
#endif
g_resCounter->LockResCounter();
GTH d3dApp;
g_pApp = &d3dApp;
g_hInst = hInst;
g_musicMng->EnableMusicMng();
g_musicMng->LockMusicMng();
#ifdef _GTH_ONLINE_VERSION
g_cgv.state = CLIENT_START_PROCESS;
#else
GTH_InitClientGlobalVariable();
g_cgv.state = CLIENT_LOADING_PROCESS;
#endif
g_cgv.currentWorldIdx = -1;
if( !d3dApp.InitEngine( hInst ) )
{
return 0;
}
#if defined(_DEBUG) && defined(_AHNLAB_HACKSHIELD)
gcAhnLabHackShieldCtrl.LPackTest();
#endif
g_timer.Start();
g_musicMng->Initialize( g_pApp->m_hWnd );
GTH_LoadOptionFromFile();
if( !g_input->CreateDevice() ) return( 0 );
if( !g_input->CreateKeyDevice( DISCL_NONEXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY ) ) return 0;
if( !g_input->CreateMouseDevice( DISCL_NONEXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY ) ) return 0;
d3dApp.InitIME();
d3dApp.Run();
#ifdef _GTH_ONLINE_VERSION
GTH_ShutdownGame();
#endif
#ifdef _AHNLAB_HACKSHIELD
gcAhnLabHackShieldCtrl.ServiceEnd();
#endif
return 0;
}
int GTH::InitEngine( HINSTANCE hInst )
{
if( !PrepareApp() )
return false;
if( FAILED( Create( hInst ) ) )
return false;
assert(NULL != g_cpNProtect);
#ifdef _GTH_ONLINE_VERSION
#ifdef _GTH_ENABLE_GOODNOTICE
if ( !GTH_StartUpGame(NONE_MASTERSERVER_CONNECT) ) return false;
#else
if ( !GTH_StartUpGame() ) return false;
#endif
#endif
return true;
}
int GTH::InitIME()
{
int nKLList = GetKeyboardLayoutList( 0, NULL );
HKL *pHKLList = new HKL[nKLList];
GetKeyboardLayoutList( nKLList, pHKLList );
int ret = 1;
for( int i=0 ; i<nKLList ; i++ )
{
if( !ActivateKeyboardLayout( pHKLList[i], KLF_SETFORPROCESS ) )
{
ErrorLog( "ActivateKeyboardLayout Failed(%d)", pHKLList[i]);
ret = 0;
}
}
ActivateKeyboardLayout( pHKLList[0], KLF_SETFORPROCESS );
delete[] pHKLList;
m_IMEReady = true;
return ret;
return 1;
}
GTH::GTH()
{
m_dwCreationWidth = 1024;
m_dwCreationHeight = 768;
m_strWindowTitle = TEXT( "GTH" );
m_bUseDepthBuffer = TRUE;
m_pD3DXFont = NULL;
m_bLoadingApp = TRUE;
m_numWorldBSPs = 0;
m_numMapInfos = 0;
m_currWorld = 0;
m_frameFlag = 0;
gcpGMCtrl = new CGMCtrl();
if(NULL == gcpGMCtrl) return;
if(FALSE == gcpGMCtrl->isOK()){ delete gcpGMCtrl; gcpGMCtrl=NULL; return; }
g_modelShaderMng = new CShaderMng;
g_charShaderMng = new CShaderMng;
g_move = new CMove;
g_entityMng = new CEntityMng;
g_itemMng = new CItemMng;
g_effectMng = new CEffectMng;
g_cursor = new CCursor;
g_timeSystem = new CTimeSystem;
g_musicMng = new CMusicMng;
input = new input_t;
g_charManager = new FX_CCharManager;
g_chatManager = new CChatManager;
g_soundMng = new CSoundMng;
g_input = new CInputMng;
g_ifMng = new CIFManager;
g_cpGuildCtrl = new CGuildCtrl();
g_TutorialMng = new CTutorialMng;
memset ( m_worldBSPs, 0, sizeof(m_worldBSPs) );
m_MDLMng = NULL;
memset( m_mapInfos, 0, sizeof(m_mapInfos) );
m_IMEReady = false;
//lucky 2012 Windowed all gth .
m_bFullScreen = false;
m_bWindowed = true;
//end
#if defined _GTH_CHINESE_VERSION || _GTH_TERRA_VERSION || _GTH_TAIWAN_VERSION || _GTH_MALAYSIA_CHN_VERSION
HDC hDC;
hDC = GetDC( NULL );
GetDeviceGammaRamp( hDC, &m_ramp );
ReleaseDC( NULL, hDC );
#endif
}
GTH::~GTH()
{
#if defined _GTH_CHINESE_VERSION || _GTH_TERRA_VERSION || _GTH_TAIWAN_VERSION || _GTH_MALAYSIA_CHN_VERSION
if( m_bChangeDisplay ) ChangeDisplaySettingsEx( NULL ,NULL, NULL, 0, NULL );
HDC hDC;
hDC = GetDC( NULL );
SetDeviceGammaRamp( hDC, &m_ramp );
ReleaseDC( NULL, hDC );
#endif
int i = 0;
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
case CLIENT_LOGIN_PROCESS :
case CLIENT_CHARACTER_PROCESS :
case CLIENT_LOADING_PROCESS :
case CLIENT_GAME_PROCESS :
for( i = 0 ; i < m_numWorldBSPs ; i++ )
GTH_SAFE_DELETE( m_worldBSPs[ i ] );
GTH_SAFE_DELETE( m_MDLMng );
break;
}
if(NULL != gcpGMCtrl){ delete gcpGMCtrl; gcpGMCtrl=NULL; }
GTH_SAFE_DELETE( g_modelShaderMng );
GTH_SAFE_DELETE( g_charShaderMng );
GTH_SAFE_DELETE( g_move );
GTH_SAFE_DELETE( g_entityMng );
GTH_SAFE_DELETE( g_itemMng );
GTH_SAFE_DELETE( g_effectMng );
GTH_SAFE_DELETE( g_cursor );
GTH_SAFE_DELETE( g_timeSystem );
GTH_SAFE_DELETE( g_musicMng );
GTH_SAFE_DELETE( g_chatManager );
g_ifMng->FinalCleanup();
GTH_SAFE_DELETE( g_ifMng );
if(NULL != g_cpGuildCtrl){ delete g_cpGuildCtrl; g_cpGuildCtrl=NULL; }
g_charManager ->Cleanup ();
GTH_SAFE_DELETE( g_charManager );
GTH_SAFE_DELETE( g_soundMng );
GTH_SAFE_DELETE( input );
g_input->FreeMouseDevice();
g_input->FreeKeyDevice();
g_input->FreeDevice();
GTH_SAFE_DELETE( g_input );
GTH_SAFE_DELETE( g_TutorialMng );
g_resCounter->PrintOut();
}
void GTH::InitGlobalClass()
{
g_shaderMng.SetOwner( OWNER_TYPE_BSP );
g_modelShaderMng->SetOwner( OWNER_TYPE_MODEL );
g_charShaderMng->SetOwner( OWNER_TYPE_CHARACTER );
g_move->SetTimer( &g_timer );
g_entityMng->SetScript( &g_script );
g_entityMng->SetTimer( &g_timer );
g_entityMng->SetCamara( &g_camera );
g_entityMng->SetMover( g_move );
g_entityMng->SetCharacterMng( g_charManager );
g_entityMng->SetFrustum( &(g_camera.m_frustum) );
g_itemMng->SetScript( &g_script );
g_itemMng->SetFrustum( &(g_camera.m_frustum) );
g_effectMng->SetScript( &g_script );
g_effectMng->SetFrustum( &(g_camera.m_frustum) );
g_cursor->SetEffectMng( g_effectMng );
g_timeSystem->SetRenderer( &g_d3dRender );
g_charManager->SetFileManager( &g_fileMng );
g_charManager->SetTexManager( &g_texMng );
g_charManager->SetScript( &g_script );
g_charManager->SetTimer( &g_timer );
g_charManager->SetShaderMng( g_charShaderMng );
g_charManager->SetRenderer( &g_d3dRender );
g_charManager ->SetFrustum ( &(g_camera.m_frustum) );
g_chatManager->SetFileMng( &g_fileMng );
g_ifMng->InitDeviceObjects();
g_ifMng->SetFileManager( &g_fileMng );
g_ifMng->SetScript( &g_script );
g_ifMng->SetTexManager( &g_texMng );
g_TutorialMng->SetFileMng(&g_fileMng);
g_LPACK.SetFileManager(&g_fileMng);
g_effectMng->SetNumberCtl( g_ifMng->m_numCtl );
}
#include "CGameVersion.h"
CGameVersion* g_GameVersion = NULL;
int GTH::PrepareApp()
{
char* token;
int ret;
InitGlobalClass();
#ifdef _GTH_ZIP_VERSION_PACK
ret = g_fileMng.PreparePackFiles(ZIP_VERSION_PACK);
#else
ret = g_fileMng.PreparePackFiles(I3D_VERSION_PACK);
#endif
if( !ret )
return false;
g_charManager->LoadAllResources();
ret = LoadShaders();
if( !ret ) return false;
g_script.Load( "start.cfg" );
g_script.BeginParse();
token = g_script.GetNextToken( true );
strcpy( g_cgv.worldInfo, token );
if ( !GTH_LoadWorldTable() ) return false;
if ( !GTH_ParseGameConfig() ) return false;
g_LPACK.Init();
#ifdef _AHNLAB_HACKSHIELD
if(FALSE == gcAhnLabHackShieldCtrl.ServiceStart()){
return 0;
}
#endif
g_GameVersion = new CGameVersion;
if ( g_GameVersion == NULL)
{
MessageBox( NULL, "Create Gameversion Error", "Error", MB_OK );
return false;
}
strncpy(g_cgv.gameVersion, g_GameVersion->m_szMasterServerVersion, VERSIONSTRING);
g_cgv.gameVersion[VERSIONSTRING-1] = NULL;
if( !LoadAllGameTable() ) return 0;
GTH_GenerateMyCharacter();
check.timer.Start();
#ifdef _GTH_MALAYSIA_CHN_VERSION
g_chatManager->SetChat(GTH_LANGUAGE_TYPE_SIMPLIFIED_CHINESE, 1 );
#else
#if defined _GTH_CHINESE_VERSION || _GTH_TERRA_VERSION || _GTH_TAIWAN_VERSION
g_chatManager->SetChat( g_cgv.languageType, 1 );
#else
g_chatManager->SetChat( g_cgv.languageType, 0 );
#endif
#endif
if( !g_ifMng->LoadConfig( "if.cfg" ) )
{
MessageBox( NULL, "Interface config loading fail!!", "Error", MB_OK );
return false;
}
g_ifMng->m_cursor->MakeCursor();
g_soundMng->LoadSoundConfig( "sound.cfg" );
g_soundMng ->LoadMDLSoundConfig ( "test.sound.class" );
return true;
}
int GTH::ChangeClientState( int state )
{
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
ChangeStartProcessBefore();
g_input->ChangeCursor();
g_input->Show();
break;
case CLIENT_LOGIN_PROCESS :
break;
case CLIENT_CHARACTER_PROCESS :
ChangeCharProcessBefore();
break;
case CLIENT_LOADING_PROCESS :
ChangeLoadingProcessBefore();
break;
case CLIENT_GAME_PROCESS :
ChangeGameProcessBefore();
break;
}
g_cgv.state = (clientProcessState_t)state;
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
ChangeStartProcessAfter();
break;
case CLIENT_LOGIN_PROCESS :
ChangeLoginProcessAfter();
break;
case CLIENT_CHARACTER_PROCESS :
ChangeCharProcessAfter();
break;
case CLIENT_LOADING_PROCESS :
ChangeLoadingProcessAfter();
break;
case CLIENT_GAME_PROCESS :
ChangeGameProcessAfter();
break;
}
return( 1 );
}
int GTH::RestoreApp()
{
int before, after, tick;
before = timeGetTime();
g_texMng.SetTextureQuality( g_userConfig.texture );
#if defined _GTH_CHINESE_VERSION || _GTH_TERRA_VERSION || _GTH_TAIWAN_VERSION || _GTH_MALAYSIA_CHN_VERSION
g_display.m_gammaRampType = 2;
#else
g_display.m_gammaRampType = 1;
#endif
g_display.SetupGamma();
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_MODEL_MAP );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_MODEL_LIGHTMAP );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_MODEL_OTHERS );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_CHAR_PC );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_CHAR_NPC );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_CHAR_MONSTER );
g_resCounter->Reset_DataType( RESCOUNTER_TEXTURE_INTERFACE );
g_charManager->m_pAnimManager->LoadActualData();
if( m_MDLMng == NULL )
{
switch( g_cgv.state )
{
case CLIENT_START_PROCESS : case CLIENT_LOGIN_PROCESS : case CLIENT_CHARACTER_PROCESS :
InitStartProcess();
break;
case CLIENT_LOADING_PROCESS :
InitLoadingProcess();
break;
case CLIENT_GAME_PROCESS :
InitGameProcess();
break;
}
}
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
RestoreStartProcess();
break;
case CLIENT_LOGIN_PROCESS :
RestoreLoginProcess();
break;
case CLIENT_CHARACTER_PROCESS :
RestoreCharProcess();
break;
case CLIENT_LOADING_PROCESS :
RestoreLoadingProcess();
break;
case CLIENT_GAME_PROCESS :
RestoreGameProcess();
break;
}
after = timeGetTime();
tick = after - before;
return true;
}
int GTH::InitApp()
{
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
InitStartProcess();
break;
case CLIENT_LOGIN_PROCESS :
InitLoginProcess();
break;
case CLIENT_CHARACTER_PROCESS :
InitCharProcess();
break;
case CLIENT_LOADING_PROCESS :
InitLoadingProcess();
break;
case CLIENT_GAME_PROCESS :
InitGameProcess();
break;
}
return true;
}
void GTH::InitCharacter()
{
g_move->SetWorldModel( m_worldBSPs[ 0 ] );
#ifdef _GTH_ONLINE_VERSION
g_charManager->m_iNumCharacters = 0;
g_charManager->m_iNumBackupCharacters = 0;
g_cgv.syncCharacter[0].position[0] += m_worldBSPs[0]->m_models->bbox[0];
g_cgv.syncCharacter[0].position[1] += m_worldBSPs[0]->m_models->bbox[1];
g_cgv.syncCharacter[0].position[2] += m_worldBSPs[0]->m_models->bbox[2];
g_charManager->GenerateCharacter(g_cgv.syncCharacter, 1);
SetMyCharacter();
GTH_Network_InitNetTime();
g_cgv.enableChat = true;
if ( m_mapInfos [m_myCharacter ->worldIdx].weather != TIME_DAY )
g_timeSystem->SetTimeStateEnv ( m_mapInfos [m_myCharacter ->worldIdx].weather );
#else
g_charManager->m_iNumCharacters = 0;
g_charManager->m_iNumBackupCharacters = 0;
g_cgv.enableChat = true;
g_cgv.syncCharacterNumber = 1;
g_cgv.syncCharacter[0].speed = 10.0f;
g_charManager->GenerateCharacter(g_cgv.syncCharacter, g_cgv.syncCharacterNumber);
g_charManager->m_Characters[0].isAlive = true;
SetMyCharacter();
#endif
}
void GTH::ApplyTimeEnv()
{
vec3_t pos;
VectorSet( pos , 0.0f , 0.0f , 0.0f );
g_timeSystem->SetLightPos( pos );
g_timeSystem->SetLightDir( m_mapInfos[ 0 ].sunAngle );
g_timeSystem->ApplyTimeEnv();
}
void GTH::OutputClientState()
{
g_chatManager->SetDFontColor( 0xffff0000 );
char temp[255];
#ifdef _GTH_ONLINE_VERSION
strcpy( temp, "ONLINE - " );
#else
strcpy( temp, "OFFLINE - " );
#endif
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
strcat( temp, "STATE : CLIENT_START_PROCESS" );
break;
case CLIENT_LOGIN_PROCESS :
strcat( temp, "STATE : CLIENT_LOGIN_PROCESS" );;
break;
case CLIENT_CHARACTER_PROCESS :
strcat( temp, "STATE : CLIENT_CHARACTER_PROCESS" );
break;
case CLIENT_LOADING_PROCESS :
strcat( temp, "STATE : CLIENT_LOADING_PROCESS" );
break;
case CLIENT_GAME_PROCESS :
strcat( temp, "STATE : CLIENT_GAME_PROCESS" );
break;
}
g_chatManager->DPrint( 10, 10, temp );
}
HRESULT GTH::AppFrame()
{
OutputClientState();
m_fElapsedTime = g_timer.Tick();
m_fTime = g_timer.GetAppTime();
g_input->ReadKeyImmediateData();
g_input->ReadMouseImmediateData();
if( g_input->KeyEvent( DIK_LALT ) || g_input->KeyEvent( DIK_RALT ) )
{
if( g_input->KeyDown( DIK_TAB ) )
{
}
}
#ifndef _GTH_ONLINE_VERSION
if( g_input->KeyEvent( DIK_LCONTROL ) )
{
if(g_input->KeyDown(DIK_1))
{
g_display.SetBrightness(g_display.GetBrightness() + 0.1f);
g_display.SetupGamma();
}
else if(g_input->KeyDown(DIK_2))
{
g_display.SetBrightness(g_display.GetBrightness() - 0.1f);
g_display.SetupGamma();
}
else if(g_input->KeyDown(DIK_3))
{
g_display.SetGamma(g_display.GetGamma() + 0.1f);
g_display.SetupGamma();
}
else if(g_input->KeyDown(DIK_4))
{
g_display.SetGamma(g_display.GetGamma() - 0.1f);
g_display.SetupGamma();
}
else if(g_input->KeyDown(DIK_5))
{
g_display.SetContrast(g_display.GetContrast() + 0.1f);
g_display.SetupGamma();
}
else if(g_input->KeyDown(DIK_6))
{
g_display.SetContrast(g_display.GetContrast() - 0.1f);
g_display.SetupGamma();
}
if(g_input->KeyDown( DIK_R))
{
g_display.SetGamma( 1.3f );
g_display.SetBrightness( 0.6f );
g_display.SetContrast( 1.0f );
g_display.SetupGamma();
}
}
g_chatManager->HPrint( 200, 100,
"Brightness : %.2f(Ctrl + 1,2), Gamma : %.2f(Ctrl + 3,4), Contrast : %.2f(Ctrl + 5,6) - reset(Ctrl + R)",
g_display.GetBrightness(), g_display.GetGamma(), g_display.GetContrast() );
#endif
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
if( StartProcessFrame() == E_FAIL ) return S_OK;
break;
case CLIENT_LOGIN_PROCESS :
if( LoginProcessFrame() == E_FAIL ) return S_OK;
break;
case CLIENT_CHARACTER_PROCESS :
if( CharProcessFrame() == E_FAIL ) return S_OK;
break;
case CLIENT_LOADING_PROCESS :
if( LoadingProcessFrame() == E_FAIL ) return S_OK;
break;
case CLIENT_GAME_PROCESS :
if( GameProcessFrame() == E_FAIL )
{
return S_OK;
}
break;
}
extern int g_viewSide;
if( g_viewSide == 1 )
{
g_camera.m_angles[ YAW ] += 90.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] -= 90.0f;
g_camera.SetupVectors();
}
else if( g_viewSide == 2 )
{
g_camera.m_angles[ YAW ] += 180.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] -= 180.0f;
g_camera.SetupVectors();
}
else if( g_viewSide == 3 )
{
g_camera.m_angles[ YAW ] -= 90.0f;
g_camera.SetupMatrices( false );
g_camera.m_angles[ YAW ] += 90.0f;
g_camera.SetupVectors();
}
g_input->UpdateKeyData();
g_input->UpdateMouseData();
g_chatManager->Update();
return S_OK;
}
int GTH::AppProcess()
{
int ret = false;
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
ret = StartProcess();
break;
case CLIENT_LOGIN_PROCESS :
ret = LoginProcess();
break;
case CLIENT_CHARACTER_PROCESS :
ret = CharProcess();
g_charManager->FixCharacterPosition();
break;
case CLIENT_LOADING_PROCESS :
ret = LoadingProcess();
break;
case CLIENT_GAME_PROCESS :
ret = GameProcess();
g_charManager->FixCharacterPosition();
break;
}
if( g_input->KeyDown( DIK_SYSRQ ) )
MakeScreenShot( m_pd3dDevice, m_d3dsdBackBuffer.Width, m_d3dsdBackBuffer.Height );
return( ret );
}
void GTH::WorldRenderBefore()
{
SetWorldTransform();
if ( m_renderEnabled )
{
m_worldBSPs[ m_currWorld ]->RenderBefore();
}
}
void GTH::WorldRenderAfter()
{
SetWorldTransform();
if ( m_renderEnabled )
{
m_worldBSPs[ m_currWorld ]->RenderAfter();
}
}
void GTH::WorldFrame()
{
if( g_stop ) return;
m_worldBSPs[ m_currWorld ]->PrepareScene( g_camera.m_position , m_frameFlag );
}
void GTH::EntityFrame()
{
m_MDLMng->SetEnvironmentMatrix( g_camera.GetEnvironmentMatrix() );
m_MDLMng->SetCamera( g_camera.m_position , g_camera.m_angles );
m_MDLMng->SetVisData( m_worldBSPs[ m_currWorld ]->GetVisData() );
if ( m_renderEnabled )
m_MDLMng->Render();
}
void GTH::CharacterFrame()
{
if ( m_renderEnabled )
{
g_charManager->SetRenderState ();
g_charManager->RenderItems();
g_charManager->PrepareSkinRendering();
g_charManager->RenderSkinsNormal();
g_charManager->RenderAuras();
g_charManager->RenderSkinsDisappear();
g_charManager->RenderShadow ();
g_charManager->RenderEffects();
}
g_charManager->EndFrame ();
}
void GTH::CursorFrame()
{
}
void GTH::SetupCamera()
{
g_camera.AdjustCameraAngle( m_myCharacter->position , m_myCharacter->angles , g_timer.GetElapsedTime() );
g_camera.AdjustCamera( m_myCharacter->position , m_myCharacter->angles );
if ( g_charManager ->m_tbDo )
{
vec3_t trembleDelta;
trembleDelta [0] = sin ( g_timer .GetAppTime () * 70.0f ) * 5.0f * g_charManager ->m_tbPower;
trembleDelta [1] = cos ( g_timer .GetAppTime () * 68.0f ) * 5.0f * g_charManager ->m_tbPower;
trembleDelta [2] = sin ( g_timer .GetAppTime () * 66.0f ) * cos ( g_timer .GetAppTime () * 64.0f ) * 5.0f * g_charManager ->m_tbPower;
VectorAdd ( g_camera .m_position, g_camera .m_position, trembleDelta );
}
g_camera.SetupMatrices( true );
}
void GTH::SetWorldTransform()
{
g_d3dRender.SetTransform( D3DTS_WORLD , &g_camera.m_worldMat );
g_d3dRender.SetTransform( D3DTS_VIEW , &g_camera.m_viewMat );
g_d3dRender.SetTransform( D3DTS_PROJECTION , &g_camera.m_projMat );
}
void GTH::SetMyCharacter()
{
vec3_t delta;
VectorClear( delta );
m_myCharacter = &g_charManager->m_Characters[0];
VectorSet( m_myCharacter->mins , -16.0f , -16.0f , -24.0f );
VectorSet( m_myCharacter->maxs , 16.0f , 16.0f , 32.0f );
g_camera.m_angles[ YAW ] = m_myCharacter->angles[ YAW ] + 180;
g_camera.m_distance = -100;
m_myCharacter->SetupVectors();
g_move->Pmove( m_myCharacter->position , delta , m_myCharacter->angles );
g_charManager->StartFrame();
g_charManager->UpdateAnimations();
m_myCharacter->targetIdx = -1;
m_myCharacter->targetType = -1;
m_myCharacter->atk_resend = false;
}
char* g_eventString[] =
{
"GTH_EV_CHAR_IDLE",
"GTH_EV_CHAR_WALK",
"GTH_EV_CHAR_WALKLEFT",
"GTH_EV_CHAR_WALKRIGHT",
"GTH_EV_CHAR_BACK",
"GTH_EV_CHAR_BACKLEFT",
"GTH_EV_CHAR_BACKRIGHT",
"GTH_EV_CHAR_RUN",
"GTH_EV_CHAR_RUNLEFT",
"GTH_EV_CHAR_RUNRIGHT",
"GTH_EV_CHAR_TURNLEFT",
"GTH_EV_CHAR_TURNRIGHT",
"GTH_EV_CHAR_MOVELEFT",
"GTH_EV_CHAR_MOVERIGHT",
"GTH_EV_CHAR_ATTACK",
"GTH_EV_CHAR_DIE",
"GTH_EV_CHAR_STUN",
"GTH_EV_CHAR_DAMAGE",
"GTH_EV_CHAR_RESPAWN",
"GTH_EV_CHAR_SKIP",
"GTH_EV_CHAR_MOUSEWALK",
"GTH_EV_CHAR_MOUSERUN",
"GTH_EV_CHAR_SIT",
"GTH_EV_CHAR_STAND",
"GTH_EV_CHAR_SKILL",
};
char* g_ceventString[] =
{
"GTH_CEV_CHAR_IDLE",
"GTH_CEV_CHAR_ATTACK",
"GTH_CEV_CHAR_PICKUP_ITEM",
"GTH_CEV_CHAR_NPC_REQUEST",
"GTH_CEV_CHAR_PC_REQUEST",
"GTH_CEV_CHAR_SKILL",
};
HRESULT GTH::FrameMove()
{
if( m_myCharacter->isAlive && g_cgv.state == CLIENT_GAME_PROCESS )
{
SetupCursor_Neo();
GTH_SetMyCharacterMouseEvent( m_myCharacter );
}
if ( g_cgv.state == CLIENT_GAME_PROCESS)
g_NewDanBattleSystem.Update();
float succeccRate = 0.0f;
int totalCount = g_AttackProc.m_ntempAttackMissCount + g_AttackProc.m_ntempAttackSuccessCount;
if( totalCount > 0 )
{
succeccRate = (float)g_AttackProc.m_ntempAttackSuccessCount / (float)totalCount * 100.0f;
}
g_chatManager->DPrint( 300, 100, "Result HitRate : %d, Avoid Rate : %d", g_cgv.myCharacterInfo->resultHitRate, g_cgv.myCharacterInfo->resultAvoidRate );
g_chatManager->DPrint( 300, 130, "Succuss : %d, Miss : %d, Rate : %.2f", g_AttackProc.m_ntempAttackSuccessCount, g_AttackProc.m_ntempAttackMissCount, succeccRate );
g_chatManager->DPrint( 200, 0, "resendAttack(%d), saveEvent(%d), atk_changeEvent(%d), atk_replyAnim(%d), atk_resend(%d)",
g_cgv.resendAttack, g_cgv.saveEvent, m_myCharacter->atk_changeEvent, m_myCharacter->atk_playAnim, m_myCharacter->atk_resend );
g_chatManager->DPrint( 350, 400, "missCount : %d, minSyncTime : %.2f, maxSyncTime : %.2f",
g_cgv.missSyncTimeCount, g_cgv.minSyncTime, g_cgv.maxSyncTime );
g_chatManager->DPrint( 350, 408, "saveEvent : %d, event : %d", g_cgv.saveEvent, g_pApp->m_myCharacter->event );
return S_OK;
}
int GTH::ChangeResolution ( int in_mode )
{
D3DAdapterInfo *pAdapterInfo = &m_Adapters [m_dwAdapter];
D3DDeviceInfo *pDeviceInfo = &pAdapterInfo ->devices [pAdapterInfo ->dwCurrentDevice];
D3DModeInfo *pModeInfo = &pDeviceInfo ->modes [pDeviceInfo ->dwCurrentMode];
D3DModeInfo newMode;
memcpy ( &newMode, pModeInfo, sizeof(D3DModeInfo) );
switch ( in_mode )
{
case GTH_RES_800_600:
newMode.Width = 800;
newMode.Height = 600;
break;
case GTH_RES_1024_768:
newMode.Width = 1024;
newMode.Height = 768;
case GTH_RES_1280_1024:
newMode.Width = 1280;
newMode.Height = 1024;
case GTH_RES_1600_1200:
newMode.Width = 1600;
newMode.Height = 1200;
}
D3DModeInfo *thisMode;
int found = false;
for ( int index = 0; \
index < pDeviceInfo ->dwNumModes; \
index++ )
{
thisMode = &pDeviceInfo ->modes [index];
if ( 0 == memcmp ( thisMode, &newMode, sizeof(D3DModeInfo) ) )
{
found = index;
break;
}
}
if ( found )
{
pDeviceInfo ->dwCurrentMode = found;
}
else
{
return false;
}
InvalidateDeviceObjects ();
DeleteDeviceObjects ();
if( m_pd3dDevice->Release() > 0L )
return DisplayErrorMsg( D3DAPPERR_NONZEROREFCOUNT, MSGERR_APPMUSTEXIT );
HRESULT hr;
if( FAILED( hr = Initialize3DEnvironment() ) )
return DisplayErrorMsg( hr, MSGERR_APPMUSTEXIT );
if( FALSE == m_bFrameMoving )
{
m_bSingleStep = TRUE;
DXUtil_Timer( TIMER_START );
DXUtil_Timer( TIMER_STOP );
}
g_ifMng ->ChangeResolution ( newMode.Width, newMode.Height );
return true;
}
void GTH::ToggleFullScreen ()
{
if ( ! m_bWindowed )
{
ChangeResolution ( 0 );
}
CD3DApplication::ToggleFullscreen ();
}
| C++ |
#include "stdafx.h"
#include "CGameVersion.h"
CGameVersion::CGameVersion()
{
m_iClientGameVersion = 2.12 ;
strncpy(m_szMasterServerVersion, "lol", VERSIONSTRING);
m_szMasterServerVersion[VERSIONSTRING] = NULL;
}
CGameVersion::~CGameVersion()
{
}
| C++ |
#include <afxwin.h>
#include "resource.h"
#include "input.h"
extern HINSTANCE g_hInst;
void mouse_t::ChangeCursor( int type )
{
oldCursorState = cursorState;
return;
switch( type )
{
case MOUSE_CURSOR_NULL :
cursorState = MOUSE_CURSOR_NULL;
SetCursor( NULL );
break;
case MOUSE_CURSOR_POINTER :
cursorState = MOUSE_CURSOR_POINTER;
hCur = LoadCursor( g_hInst, MAKEINTRESOURCE( IDC_POINTER ) );
SetCursor( hCur );
break;
case MOUSE_CURSOR_ATTACK :
cursorState = MOUSE_CURSOR_ATTACK;
hCur = LoadCursor( g_hInst, MAKEINTRESOURCE( IDC_POINTER_ATTACK ) );
SetCursor( hCur );
break;
case MOUSE_CURSOR_CHAT :
cursorState = MOUSE_CURSOR_CHAT;
hCur = LoadCursor( g_hInst, MAKEINTRESOURCE( IDC_POINTER_CHAT ) );
SetCursor( hCur );
break;
case MOUSE_CURSOR_REPAIR :
cursorState = MOUSE_CURSOR_REPAIR;
hCur = LoadCursor( g_hInst, MAKEINTRESOURCE( IDC_POINTER_REPAIR ) );
SetCursor( hCur );
break;
}
}
void mouse_t::Show()
{
ChangeCursor( MOUSE_CURSOR_POINTER );
}
void mouse_t::Hide()
{
ChangeCursor( MOUSE_CURSOR_NULL );
}
void mouse_t::Resize( int width , int height )
{
mid.x = width >> 1;
mid.y = height >> 1;
}
void mouse_t::GetCursorPos( POINT& p )
{
if( middle_button || forcedMode )
{
if( currMode != SCROLL_MODE && !forcedMode )
{
oldMode = currMode;
currMode = SCROLL_MODE;
Center();
p.x = 0;
p.y = 0;
}
else
{
p.x = pos.x - mid.x;
p.y = pos.y - mid.y;
if( p.x || p.y )
Center();
}
}
else
{
if( currMode == SCROLL_MODE && !forcedMode )
{
oldMode = currMode;
currMode = NORMAL_MODE;
ClientToScreen( hWnd , &currPos );
SetCursorPos( currPos.x , currPos.y );
}
else
{
prevPos = currPos;
currPos = pos;
p = currPos;
}
}
}
void mouse_t::GetDelta( POINT& p )
{
p.x = currPos.x - prevPos.x;
p.y = currPos.y - prevPos.y;
}
void mouse_t::Center()
{
}
int mouse_t::GetWheelDelta()
{
if( isWheeled && wheelDelta != 0 )
{
isWheeled = false;
return wheelDelta;
}
return 0;
}
int mouse_t::GetButtonState( mouseButton_t state, int type )
{
int curState = 0;
curState = left_button | ( right_button << 1 ) | ( left_dbclick << 2 ) | ( right_dbclick << 3 );
if( !type )
{
if( left_button && ( MOUSE_LEFT_BUTTON & state ) ) left_button = 0;
if( right_button && ( MOUSE_RIGHT_BUTTON & state ) ) right_button = 0;
if( left_dbclick && ( MOUSE_LEFT_DBCLICK & state ) ) left_dbclick = 0;
if( right_dbclick && ( MOUSE_RIGHT_DBCLICK & state ) ) right_dbclick = 0;
}
return( curState & state );
}
int mouse_t::GetLeftClicked()
{
if( !left_button_clicked ) return( false );
else if( left_button == 0 )
{
left_button_clicked = 0;
return( true );
}
return( false );
}
int mouse_t::GetRightClicked()
{
if( !right_button_clicked ) return( false );
else if( right_button == 0 )
{
right_button_clicked = 0;
return( true );
}
return( false );
}
| C++ |
#if !defined(AFX_CGAMEVERSION_H__87673604_4663_491F_A3F1_0E2C0B1B0B35__INCLUDED_)
#define AFX_CGAMEVERSION_H__87673604_4663_491F_A3F1_0E2C0B1B0B35__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define VERSIONSTRING 20
class CGameVersion
{
public:
float m_iClientGameVersion;
char m_szMasterServerVersion[VERSIONSTRING+1];
public:
CGameVersion();
virtual ~CGameVersion();
};
#endif
| C++ |
#if !defined(AFX_CTOOLS_H__B2A34627_FBC4_4ED9_9AF4_E16AE9AA4393__INCLUDED_)
#define AFX_CTOOLS_H__B2A34627_FBC4_4ED9_9AF4_E16AE9AA4393__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CTools
{
private:
BOOL m_bOK;
public:
BOOL isOK(void) const;
static void Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(char* ntspString);
static void Replace_doubleQUOTATIONmark_by_singleQUOTATIONmark(char* ntspString);
public:
int GetEpkChargeCount(item_t *pItem);
void SetEpkChargeCount(item_t *pItem,int count);
Fx_CHARACTER_t * FindCharacter(const int EntityType,const int IdxOnServer);
bool IfMyCharacter(const Fx_CHARACTER_t *character);
bool IfSkillCasting_NotItemUse();
bool DeleteInventoryItem(int invenPos);
void CcToGs(int sysType,int mainType,int subType);
void CcToGs(int sysType,int mainType,int subType,int val);
void CcToGs(int sysType,int mainType,int subType,char *TargetPlayerName);
void CcToGs(int sysType,int mainType,int subType,int val, char *TargetPlayerName);
void CcToGs(int sysType,int mainType,int subType,int worldIdx,vec3_t position, char *TargetPlayerName);
void CcToGs(int sysType,int mainType,int subType, char *RequestPlayerName, char *TargetPlayerName);
void CcToGs(int sysType,int mainType,int subType, int worldIdx, vec3_t position, char *RequestPlayerName, char *TargetPlayerName);
public:
CTools();
virtual ~CTools();
};
#endif
| C++ |
#include "../global_def.h"
CShaderMng *g_modelShaderMng;
CShaderMng *g_charShaderMng;
CMove *g_move;
CEntityMng *g_entityMng;
CItemMng *g_itemMng;
CEffectMng *g_effectMng;
CCursor *g_cursor;
CTimeSystem *g_timeSystem;
CMusicMng *g_musicMng;
CSoundMng *g_soundMng;
CTutorialMng *g_TutorialMng;
CLanguageManager g_LPACK;
input_t *input;
FX_CCharManager *g_charManager;
GTH* g_pApp;
HINSTANCE g_hInst;
timecheck_t check;
CChatManager *g_chatManager;
CInputMng *g_input;
CIFManager *g_ifMng;
CGuildCtrl* g_cpGuildCtrl=NULL;
CDanBattle g_DanBattle;
CGonryunBattlePractice g_GonryunBattlePractic;
CChristMasEvent g_ChristMasEvent;
CPostFunc g_PostFunc;
CWeatherSystem g_WeatherSystem;
CHelperSystem g_HelperSystem;
CGiftCard g_GiftCard;
CExpRateMng g_ExpRateMng;
NewDanBattleSystem g_NewDanBattleSystem;
chatMessage g_chatMessageBuffer [MAX_CHAT_MESSAGE_COUNT];
int g_chatMessageCount = 0;
float g_chatMessageTimeClamp [MAX_CHAT_MESSAGE_COUNT];
#ifndef _GTH_ONLINE_VERSION
int g_speedModifier = 1.0f;
#endif
| C++ |
#include "..\global_def.h"
#include "CGMCtrl.h"
#include "tagGMPacket.h"
CGMCtrl::CGMCtrl()
{
m_bOK=FALSE;
m_cpPKTimeCtrl = NULL;
m_cpChatBlockCtrl = NULL;
g_cgv.GM.bChatAllow=TRUE;
if(FALSE == Init()) return;
m_bOK=TRUE;
}
CGMCtrl::~CGMCtrl()
{
if(NULL != m_cpPKTimeCtrl){ delete m_cpPKTimeCtrl; m_cpPKTimeCtrl=NULL; }
if(NULL != m_cpChatBlockCtrl){ delete m_cpChatBlockCtrl; m_cpChatBlockCtrl=NULL; }
}
void CGMCtrl::TransmitePacket_cs_request_CSAUTH(const BOOL bEnable)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTH);
MSG_WriteLong(&netMessage,bEnable);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGMCtrl::TransmitePacket_cs_request_AUTHstate(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTHstate);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGMCtrl::TransmitePacket_cs_request_AUTH_dll_change(const char* in_strDLLFileName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_NProtect);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagNProtect::cs_request_AUTH_dll_change);
MSG_WriteString(&netMessage,(char*)in_strDLLFileName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
BOOL CGMCtrl::RunGMChatCommand( char message[], char command[], chatMessage param[] )
{
#ifdef _DEBUG
if(0 == stricmp(command,"NProtect")){
if(0 == stricmp(param[0],"changeDLL")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
if(NULL == strrchr(param[1],'.dll')) return FALSE;
TransmitePacket_cs_request_AUTH_dll_change(param[1]);
return TRUE;
}
if(0 == stricmp(param[0],"AUTH")){
if(0 == stricmp(param[1],"enable")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
TransmitePacket_cs_request_CSAUTH(TRUE);
return TRUE;
}
if(0 == stricmp(param[1],"disable")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
TransmitePacket_cs_request_CSAUTH(FALSE);
return TRUE;
}
if(0 == stricmp(param[1],"check")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
TransmitePacket_cs_request_AUTHstate();
return TRUE;
}
}
}
#endif
if(0 == stricmp(command,"pktime")){
if(0 == stricmp(param[0],"start")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
m_cpPKTimeCtrl->TransmitePacket_cs_request_change(TRUE);
return TRUE;
}
if(0 == stricmp(param[0],"end")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
m_cpPKTimeCtrl->TransmitePacket_cs_request_change(FALSE);
return TRUE;
}
if(0 == stricmp(param[0],"check")){
m_cpPKTimeCtrl->TransmitePacket_cs_request_status();
return TRUE;
}
}
if(0 == stricmp( command,"chat")){
if(0 == stricmp(param[0],"block")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
m_cpChatBlockCtrl->TransmitePacket_GMsystem_ChatBan_Block(param[1],atoi(param[2]));
return TRUE;
}
if(0 == stricmp(param[0],"allow")){
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return TRUE;
m_cpChatBlockCtrl->TransmitePacket_GMsystem_ChatBan_Allow(param[1]);
return TRUE;
}
if(0 == stricmp(param[0],"check")){
m_cpChatBlockCtrl->TransmitePacket_GMsystem_ChatBan_Req_ReaminTime();
return TRUE;
}
}
return FALSE;
}
BOOL CGMCtrl::isOK(void) const
{
return m_bOK;
}
BOOL CGMCtrl::Init(void)
{
m_cpPKTimeCtrl = new CGMCtrl_PKTimeCtrl();
if(NULL == m_cpPKTimeCtrl) return FALSE;
if(FALSE == m_cpPKTimeCtrl->isOK()){ delete m_cpPKTimeCtrl; m_cpPKTimeCtrl=NULL; return FALSE; }
m_cpChatBlockCtrl = new CGMCtrl_ChatBlockCtrl();
if(NULL == m_cpChatBlockCtrl) return FALSE;
if(FALSE == m_cpChatBlockCtrl->isOK()){ delete m_cpChatBlockCtrl; m_cpChatBlockCtrl=NULL; return FALSE; }
return TRUE;
}
inline void CGMCtrl::Decoder_NProtect_sc_response_AUTH(void)
{
BOOL bNprotectAUTHenable = MSG_ReadLong();
if(TRUE == bNprotectAUTHenable){
g_ifMng->AddChatMessage("NProtect CSAUTH enable.",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}else{
g_ifMng->AddChatMessage("NProtect CSAUTH disable.",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
}
inline void CGMCtrl::Decoder_NProtect_sc_response_AUTH_dll_change(void)
{
char strDLLname[_MAX_PATH]="";
BOOL bSuccess=MSG_ReadLong();
strncpy(strDLLname,MSG_ReadString(),_MAX_PATH);
if(TRUE == bSuccess){
g_ifMng->AddChatMessage("NProtect CSAUTH dll change success.",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
g_ifMng->AddChatMessage(strDLLname,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}else{
g_ifMng->AddChatMessage("NProtect CSAUTH dll change fail.",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
g_ifMng->AddChatMessage(strDLLname,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
}
inline void CGMCtrl::Decoder_NProtect_sc_response_AUTHstate(void)
{
BOOL bEnable=MSG_ReadLong();
if(TRUE == bEnable) g_ifMng->AddChatMessage("NProtect CSAUTH enable",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
else g_ifMng->AddChatMessage("NProtect CSAUTH disable",GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
void CGMCtrl::Decoder_NProtect(void)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTHstate:
Decoder_NProtect_sc_response_AUTHstate();
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH:
Decoder_NProtect_sc_response_AUTH();
return;
case tagExtendSecondPacket_GMsystem::tagNProtect::sc_response_AUTH_dll_change:
Decoder_NProtect_sc_response_AUTH_dll_change();
return;
}
}
void CGMCtrl::Decoder(void)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::GMsystem_NProtect:
Decoder_NProtect();
return;
case tagExtendSecondPacket_GMsystem::GMsystem_ChatBan:
m_cpChatBlockCtrl->Decoder_ChatBan();
return;
case tagExtendSecondPacket_GMsystem::GMsystem_PKtime:
m_cpPKTimeCtrl->Decoder();
return;
}
}
| C++ |
#include "..\global_def.h"
#include "CGMCtrl_PKTimeCtrl.h"
CGMCtrl_PKTimeCtrl::CGMCtrl_PKTimeCtrl()
{
m_bOK=FALSE;
m_bPK=TRUE;
m_bOK=TRUE;
}
CGMCtrl_PKTimeCtrl::~CGMCtrl_PKTimeCtrl()
{
}
BOOL CGMCtrl_PKTimeCtrl::isOK(void) const
{
return m_bOK;
}
inline void CGMCtrl_PKTimeCtrl::Decoder_sc_notify_change(void)
{
m_bPK = MSG_ReadLong();
if(TRUE == m_bPK){
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,486),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}else{
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,487),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
}
inline void CGMCtrl_PKTimeCtrl::Decoder_sc_response_status(void)
{
if(TRUE == MSG_ReadLong()){
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,488),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}else{
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,489),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
}
void CGMCtrl_PKTimeCtrl::Decoder(void)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagPKtime::sc_notify_change:
Decoder_sc_notify_change();
return;
case tagExtendSecondPacket_GMsystem::tagPKtime::sc_response_status:
Decoder_sc_response_status();
return;
}
}
void CGMCtrl_PKTimeCtrl::TransmitePacket_cs_request_change(const BOOL bPK)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::cs_request_change);
MSG_WriteLong(&netMessage, bPK);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGMCtrl_PKTimeCtrl::TransmitePacket_cs_request_status(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_PKtime);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagPKtime::cs_request_status);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
BOOL CGMCtrl_PKTimeCtrl::isPK(void) const
{
return m_bPK;
}
void CGMCtrl_PKTimeCtrl::SetPK(const BOOL bPK)
{
m_bPK=bPK;
}
| C++ |
#include "..\global_def.h"
#include "CGMCtrl_ChatBlockCtrl.h"
#include "tagGMPacket.h"
CGMCtrl_ChatBlockCtrl::CGMCtrl_ChatBlockCtrl()
{
m_bOK=FALSE;
m_bOK=TRUE;
}
CGMCtrl_ChatBlockCtrl::~CGMCtrl_ChatBlockCtrl()
{
}
BOOL CGMCtrl_ChatBlockCtrl::isOK(void) const
{
return m_bOK;
}
char* CGMCtrl_ChatBlockCtrl::GetHourMinSecondString(const int Time) const
{
static char str[100];
char temp[100];
int Hour = Time / (60 * 60);
int Min = (Time - (Hour * 60 * 60)) / 60;
int Second = (Time - (Hour * 60 * 60) - (Min * 60));
str[0]=NULL;
if(0 != Hour){ wsprintf(temp," %d%s",Hour,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,482)); strcat(str,temp); }
if(0 != Min){ wsprintf(temp," %d%s",Min,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,483)); strcat(str,temp); }
wsprintf(temp," %d%s",Second,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,484)); strcat(str,temp);
return str;
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan_sc_response_chat_block(void)
{
enum tagGMPacket_ChatBan_sc_response_chat_block::enumCode code=
(enum tagGMPacket_ChatBan_sc_response_chat_block::enumCode)MSG_ReadLong();
char szApplyPlayerName[NAMESTRING+1];
strncpy(szApplyPlayerName,MSG_ReadString(),NAMESTRING);
szApplyPlayerName[NAMESTRING-1]=NULL;
int Time = MSG_ReadLong();
char buffer[2048]="";
switch(code){
case tagGMPacket_ChatBan_sc_response_chat_block::code_success:
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,474),szApplyPlayerName,GetHourMinSecondString(Time));
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
return;
case tagGMPacket_ChatBan_sc_response_chat_block::code_not_find_player:
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,475),szApplyPlayerName);
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
return;
}
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan_sc_chat_block(void)
{
char buffer[2048]="";
int time= MSG_ReadLong();
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,476),GetHourMinSecondString(time));
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
g_cgv.GM.bChatAllow=FALSE;
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan_sc_chat_allow(void)
{
enum tagGMPacket_ChatBan_sc_chat_allow::enumCode code =
(enum tagGMPacket_ChatBan_sc_chat_allow::enumCode)MSG_ReadLong();
g_cgv.GM.bChatAllow=TRUE;
switch(code){
case tagGMPacket_ChatBan_sc_chat_allow::enumCode::code_by_GM:
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,477),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
case tagGMPacket_ChatBan_sc_chat_allow::enumCode::code_by_TimeOut:
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,478),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
default:
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,479),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
}
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan_sc_response_chat_allow(void)
{
enum tagGMPacket_ChatBan_cs_response_chat_allow::enumCode code=
(enum tagGMPacket_ChatBan_cs_response_chat_allow::enumCode)MSG_ReadLong();
char ApplyPlayerName[NAMESTRING+1]="";
strncpy(ApplyPlayerName,MSG_ReadString(),NAMESTRING);
ApplyPlayerName[NAMESTRING-1]=NULL;
char buffer[2048]="";
switch(code){
case tagGMPacket_ChatBan_cs_response_chat_allow::code_success:
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,480),ApplyPlayerName);
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
case tagGMPacket_ChatBan_cs_response_chat_allow::code_not_find_player:
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,475),ApplyPlayerName);
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
default:
g_ifMng->AddChatMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,481),GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
break;
}
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan_sc_chat_response_remain_block_time(void) const
{
int Time=MSG_ReadLong();
char buffer[2048]="";
wsprintf(buffer,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,485),GetHourMinSecondString(Time));
g_ifMng->AddChatMessage(buffer,GTHCOLOR_SYSMESSAGE,"[GTH]",IF_CHATMSG_TYPE_SYSTEM );
}
void CGMCtrl_ChatBlockCtrl::Decoder_ChatBan(void)
{
switch(MSG_ReadShort()){
case tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_allow:
Decoder_ChatBan_sc_chat_allow();
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_block:
Decoder_ChatBan_sc_chat_block();
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::sc_response_chat_block:
Decoder_ChatBan_sc_response_chat_block();
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::sc_response_chat_allow:
Decoder_ChatBan_sc_response_chat_allow();
break;
case tagExtendSecondPacket_GMsystem::tagChatBan::sc_chat_response_remain_block_time:
Decoder_ChatBan_sc_chat_response_remain_block_time();
break;
}
}
void CGMCtrl_ChatBlockCtrl::
TransmitePacket_GMsystem_ChatBan_Req_ReaminTime(void) const
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::cs_chat_request_remain_block_time);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGMCtrl_ChatBlockCtrl::TransmitePacket_GMsystem_ChatBan_Allow(const char* szpApplyPlayerName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::cs_request_chat_allow);
MSG_WriteString(&netMessage, (char*)szpApplyPlayerName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGMCtrl_ChatBlockCtrl::TransmitePacket_GMsystem_ChatBan_Block(const char* szpApplyPlayerName,const int ApplyTime)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GMsystem);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::GMsystem_ChatBan);
MSG_WriteShort(&netMessage, tagExtendSecondPacket_GMsystem::tagChatBan::cs_request_chat_block);
MSG_WriteString(&netMessage, (char*)szpApplyPlayerName);
MSG_WriteLong(&netMessage,ApplyTime);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
| C++ |
#if !defined(AFX_CGMCTRL_H__09C4E5E3_376E_4EDA_B133_1F185A1A259B__INCLUDED_)
#define AFX_CGMCTRL_H__09C4E5E3_376E_4EDA_B133_1F185A1A259B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "CGMCtrl_PKTimeCtrl.h"
#include "CGMCtrl_ChatBlockCtrl.h"
class CGMCtrl
{
private:
BOOL m_bOK;
public:
CGMCtrl_PKTimeCtrl* m_cpPKTimeCtrl;
CGMCtrl_ChatBlockCtrl* m_cpChatBlockCtrl;
private:
BOOL Init(void);
public:
BOOL isOK(void) const;
BOOL RunGMChatCommand( char message[], char command[], chatMessage param[] );
void Decoder(void);
private:
void Decoder_NProtect(void);
inline void Decoder_NProtect_sc_response_AUTH(void);
inline void Decoder_NProtect_sc_response_AUTH_dll_change(void);
inline void Decoder_NProtect_sc_response_AUTHstate(void);
void TransmitePacket_cs_request_CSAUTH(const BOOL bEnable);
void TransmitePacket_cs_request_AUTH_dll_change(const char* in_strDLLFileName);
void TransmitePacket_cs_request_AUTHstate(void);
public:
CGMCtrl();
virtual ~CGMCtrl();
};
#endif
| C++ |
#if !defined(AFX_CGMCTRL_PKTIMECTRL_H__66BE2053_FB35_47A2_8337_1754A3EF666D__INCLUDED_)
#define AFX_CGMCTRL_PKTIMECTRL_H__66BE2053_FB35_47A2_8337_1754A3EF666D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGMCtrl_PKTimeCtrl
{
private:
BOOL m_bOK;
BOOL m_bPK;
public:
BOOL isOK(void) const;
BOOL isPK(void) const;
void SetPK(const BOOL bPK);
public:
void Decoder(void);
inline void Decoder_sc_notify_change(void);
inline void Decoder_sc_response_status(void);
public:
void TransmitePacket_cs_request_change(const BOOL bPK);
void TransmitePacket_cs_request_status(void);
public:
CGMCtrl_PKTimeCtrl();
virtual ~CGMCtrl_PKTimeCtrl();
};
#endif
| C++ |
#if !defined(AFX_CGMCTRL_CHATBLOCKCTRL_H__8D691368_D718_4293_8540_EC9CA2D61721__INCLUDED_)
#define AFX_CGMCTRL_CHATBLOCKCTRL_H__8D691368_D718_4293_8540_EC9CA2D61721__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGMCtrl_ChatBlockCtrl
{
private:
BOOL m_bOK;
private:
char* GetHourMinSecondString(const int Time) const;
public:
BOOL isOK(void) const;
public:
void Decoder_ChatBan(void);
void Decoder_ChatBan_sc_response_chat_block(void);
void Decoder_ChatBan_sc_chat_block(void);
void Decoder_ChatBan_sc_chat_allow(void);
void Decoder_ChatBan_sc_response_chat_allow(void);
void Decoder_ChatBan_sc_chat_response_remain_block_time(void) const;
public:
void TransmitePacket_GMsystem_ChatBan_Block(const char* szpApplyPlayerName,const int ApplyTime);
void TransmitePacket_GMsystem_ChatBan_Allow(const char* szpApplyPlayerName);
void TransmitePacket_GMsystem_ChatBan_Req_ReaminTime(void) const;
public:
CGMCtrl_ChatBlockCtrl();
virtual ~CGMCtrl_ChatBlockCtrl();
};
#endif
| C++ |
#ifndef _FUNTION_OBJECT_H_
#define _FUNTION_OBJECT_H_
class CCUserInfo;
template<typename T>
class Tfind_if: public std::binary_function< T*, T* ,bool>{
public:
bool operator()(const T *rT ,const T *rTdec)const
{
if(*rT==*rTdec) return TRUE;
else return FALSE;
}
};
struct TDelete
{
template<typename T> void operator()(T* pT) const
{
if(pT){
delete pT;
pT=NULL;
}
}
};
#endif _FUNTION_OBJECT_H_ | C++ |
#include "vector.h"
#include <math.h>
#include "fastmath.h"
int VectorCompare( const vec3_t v1, const vec3_t v2 ) {
if (v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2]) {
return 0;
}
return 1;
}
float VectorNormalize( vec3_t v ) {
float length, ilength;
length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
length = (float) sqrt(length);
if ( length ) {
ilength = 1 / length;
v[0] *= ilength;
v[1] *= ilength;
v[2] *= ilength;
}
return length;
}
void VectorNormalizeFast( vec3_t v )
{
float ilength;
ilength = fast_rsqrt( VectorDotProduct( v, v ) );
v[0] *= ilength;
v[1] *= ilength;
v[2] *= ilength;
}
float VectorNormalize2( vec3_t out , const vec3_t v ) {
float length, ilength;
length = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
length = (float) sqrt(length);
if (length)
{
ilength = 1 / length;
out[0] = v[0] * ilength;
out[1] = v[1] * ilength;
out[2] = v[2] * ilength;
} else {
VectorClear( out );
}
return length;
}
void VectorCrossProduct( vec3_t cross , const vec3_t v1 , const vec3_t v2 ) {
cross[0] = v1[1] * v2[2] - v1[2] * v2[1];
cross[1] = v1[2] * v2[0] - v1[0] * v2[2];
cross[2] = v1[0] * v2[1] - v1[1] * v2[0];
}
float VectorLength( const vec3_t v ) {
return (float) sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );
}
float VectorDistance( const vec3_t p1, const vec3_t p2 ) {
vec3_t v;
VectorSubtract( v , p2 , p1 );
return VectorLength( v );
}
float VectorDistanceSquared( const vec3_t p1, const vec3_t p2 ) {
vec3_t v;
VectorSubtract ( v , p2, p1 );
return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
}
void VectorInverse( vec3_t v ){
v[0] = -v[0];
v[1] = -v[1];
v[2] = -v[2];
}
void Vector4Scale( vec4_t out , const vec4_t in , float scale ) {
out[0] = in[0] * scale;
out[1] = in[1] * scale;
out[2] = in[2] * scale;
out[3] = in[3] * scale;
}
void VectorRotate( vec3_t out , vec3_t in , vec3_t matrix[3] )
{
out[0] = VectorDotProduct( in , matrix[0] );
out[1] = VectorDotProduct( in , matrix[1] );
out[2] = VectorDotProduct( in , matrix[2] );
}
void VectorProjectOnPlane( vec3_t dest , vec3_t point , vec3_t planeRight , vec3_t planeUp )
{
vec3_t right , up;
float ratio;
ratio = ( VectorDotProduct( point , planeRight ) ) / ( VectorDotProduct( planeRight , planeRight ) );
VectorScale( right , planeRight , ratio );
ratio = ( VectorDotProduct( point , planeUp ) ) / ( VectorDotProduct( planeUp , planeUp ) );
VectorScale( up , planeUp , ratio );
VectorAdd( dest , right , up );
} | C++ |
#include <math.h>
#include "math.h"
#include "fastmath.h"
void AngleToVector( vec3_t angles , vec3_t forward )
{
float angle;
float sp, sy, cp, cy;
angle = deg2rad( angles[ YAW ] );
sy = (float) sin( angle );
cy = (float) cos( angle );
angle = deg2rad( angles[ PITCH ] );
sp = (float) sin( angle );
cp = (float) cos( angle );
forward[0] = cp * cy;
forward[1] = cp * sy;
forward[2] = -sp;
}
void AngleVectors( vec3_t angles , vec3_t forward , vec3_t right , vec3_t up )
{
float angle;
float sr, sp, sy, cr, cp, cy;
angle = deg2rad( angles[ YAW ] );
sy = (float) sin( angle );
cy = (float) cos( angle );
angle = deg2rad( angles[ PITCH ] );
sp = (float) sin( angle );
cp = (float) cos( angle );
angle = deg2rad( angles[ ROLL ] );
sr = (float) sin( angle );
cr = (float) cos( angle );
if( forward )
{
forward[0] = cp * cy;
forward[1] = cp * sy;
forward[2] = -sp;
}
if( right )
{
right[0] = ( -1 * sr * sp * cy + -1 * cr * -sy );
right[1] = ( -1 * sr * sp * sy + -1 * cr * cy );
right[2] = -1 * sr * cp;
}
if( up )
{
up[0] = ( cr * sp * cy + -sr * -sy );
up[1] = ( cr * sp * sy + -sr * cy );
up[2] = cr * cp;
}
}
void VectorToAngles( const vec3_t value1, vec3_t angles )
{
float forward;
float yaw, pitch;
if( value1[1] == 0.0f && value1[0] == 0.0f )
{
yaw = 0.0f;
if ( value1[2] > 0.0f ) {
pitch = 90.0f;
}
else {
pitch = 270.0f;
}
}
else
{
if ( value1[0] )
{
yaw = (float)( atan2( (double)value1[1] , (double)value1[0] ) * 180.0 / __PID );
}
else if ( value1[1] > 0.0f )
{
yaw = 90.0f;
}
else
{
yaw = 270.0f;
}
if ( yaw < 0.0f )
{
yaw += 360.0f;
}
forward = (float)( sqrt( (double)( value1[0] * value1[0] + value1[1] * value1[1] ) ) );
pitch = (float)( atan2( (double)value1[2] , (double)forward ) * 180.0 / __PID );
if ( pitch < 0.0f )
{
pitch += 360.0f;
}
}
angles[PITCH] = -pitch;
angles[YAW] = yaw;
angles[ROLL] = 0.0f;
}
float fabs( float f )
{
int tmp = * ( int * ) &f;
tmp &= 0x7FFFFFFF;
return * ( float * ) &tmp;
}
void ClearBounds( vec3_t mins , vec3_t maxs )
{
mins[0] = mins[1] = mins[2] = 99999.0f;
maxs[0] = maxs[1] = maxs[2] = -99999.0f;
}
void AddPointToBounds( vec3_t v , vec3_t mins , vec3_t maxs )
{
if( v[0] < mins[0] ) mins[0] = v[0];
if( v[0] > maxs[0] ) maxs[0] = v[0];
if( v[1] < mins[1] ) mins[1] = v[1];
if( v[1] > maxs[1] ) maxs[1] = v[1];
if( v[2] < mins[2] ) mins[2] = v[2];
if( v[2] > maxs[2] ) maxs[2] = v[2];
}
void MakeTriNormal( float* t , vec3_t fn )
{
vec3_t v1 , v2;
v1[0] = t[0] - t[3];
v1[1] = t[1] - t[4];
v1[2] = t[2] - t[5];
v2[0] = t[6] - t[3];
v2[1] = t[7] - t[4];
v2[2] = t[8] - t[5];
VectorCrossProduct( fn , v1 , v2 );
}
inline void ClearBounds2D( vec2_t mins , vec2_t maxs )
{
mins[0] = mins[1] = 99999.0f;
maxs[0] = maxs[1] = -99999.0f;
}
inline void AddPointToBounds2D( vec2_t v , vec2_t mins , vec2_t maxs )
{
if( v[0] < mins[0] ) mins[0] = v[0];
if( v[0] > maxs[0] ) maxs[0] = v[0];
if( v[1] < mins[1] ) mins[1] = v[1];
if( v[1] > maxs[1] ) maxs[1] = v[1];
}
void CalcSphereBoundBox( vec3_t mins , vec3_t maxs )
{
float distMins , distMaxs , radius;
distMins = VectorDotProduct( mins , mins );
distMaxs = VectorDotProduct( maxs , maxs );
if( distMins > distMaxs )
radius = (float) sqrt( distMins );
else
radius = (float) sqrt( distMaxs );
VectorSet( mins , -radius , -radius , mins[2] );
VectorSet( maxs , radius , radius , maxs[2] );
}
void CalcZAxisRotateBoundBox( float angle , vec3_t mins , vec3_t maxs )
{
vec2_t point2D , mins2D , maxs2D;
float cosVal , sinVal;
ClearBounds2D( mins2D , maxs2D );
cosVal = (float) cos( deg2rad( angle ) );
sinVal = (float) sin( deg2rad( angle ) );
point2D[0] = mins[0] * cosVal - mins[1] * sinVal;
point2D[1] = mins[0] * sinVal + mins[1] * cosVal;
AddPointToBounds2D( point2D , mins2D , maxs2D );
point2D[0] = mins[0] * cosVal - maxs[1] * sinVal;
point2D[1] = mins[0] * sinVal + maxs[1] * cosVal;
AddPointToBounds2D( point2D , mins2D , maxs2D );
point2D[0] = maxs[0] * cosVal - mins[1] * sinVal;
point2D[1] = maxs[0] * sinVal + mins[1] * cosVal;
AddPointToBounds2D( point2D , mins2D , maxs2D );
point2D[0] = maxs[0] * cosVal - maxs[1] * sinVal;
point2D[1] = maxs[0] * sinVal + maxs[1] * cosVal;
AddPointToBounds2D( point2D , mins2D , maxs2D );
VectorSet( mins , mins2D[0] , mins2D[1] , mins[2] );
VectorSet( maxs , maxs2D[0] , maxs2D[1] , maxs[2] );
}
void CalcZAxisRotate( float angle , vec3_t mins , vec3_t maxs )
{
float cosVal , sinVal;
vec3_t tmp;
cosVal = (float) cos( deg2rad( angle ) );
sinVal = (float) sin( deg2rad( angle ) );
tmp[0] = mins[0] * cosVal - mins[1] * sinVal;
tmp[1] = mins[0] * sinVal + mins[1] * cosVal;
mins[0] = tmp[0];
mins[1] = tmp[1];
tmp[0] = maxs[0] * cosVal - maxs[1] * sinVal;
tmp[1] = maxs[0] * sinVal + maxs[1] * cosVal;
maxs[0] = tmp[0];
maxs[1] = tmp[1];
} | C++ |
#pragma comment ( lib, "imm32.lib" )
#include <windows.h>
#include <imm.h>
class CIme{
bool g_bIme;
char g_szCompStr[ MAX_PATH ];
char g_szCompReadStr[ MAX_PATH ];
char g_szCandList[ MAX_PATH ];
int g_nImeCursor;
CANDIDATELIST *g_lpCandList;
char g_szImeName[ 64 ];
bool g_bImeSharp;
bool g_bImeSymbol;
void ConvertCandList( CANDIDATELIST *pCandList, char *pszCandList );
public:
CIme() : g_lpCandList( NULL ){ EnableIme(); }
~CIme(){
EnableIme();
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
}
void DisableIme();
void EnableIme();
void NextIme();
void SharpIme( HWND hWnd );
void SymbolIme( HWND hWnd );
char* GetImeName();
bool IfImeSharp();
bool IfImeSymbol();
void GetImeInput( char **pszCompStr, char **pszCompReadStr, int *pnImeCursor, char **pszCandList );
bool OnWM_INPUTLANGCHANGEREQUEST();
bool OnWM_INPUTLANGCHANGE( HWND hWnd );
bool OnWM_IME_SETCONTEXT(){ return true; }
bool OnWM_IME_STARTCOMPOSITION(){ return true; }
bool OnWM_IME_ENDCOMPOSITION(){ return true; }
bool OnWM_IME_NOTIFY( HWND hWnd, WPARAM wParam );
bool OnWM_IME_COMPOSITION( HWND hWnd, LPARAM lParam );
};
void CIme::DisableIme(){
while( ImmIsIME( GetKeyboardLayout( 0 )))
ActivateKeyboardLayout(( HKL )HKL_NEXT, 0 );
g_bIme = false;
g_szImeName[ 0 ] = 0;
g_szCompStr[ 0 ] = 0;
g_szCompReadStr[ 0 ] = 0;
g_szCandList[ 0 ] = 0;
g_nImeCursor = 0;
}
void CIme::EnableIme(){
g_bIme = true;
}
void CIme::NextIme(){
if( g_bIme )ActivateKeyboardLayout(( HKL )HKL_NEXT, 0 );
}
void CIme::SharpIme( HWND hWnd ){
ImmSimulateHotKey( hWnd, IME_CHOTKEY_SHAPE_TOGGLE );
}
void CIme::SymbolIme( HWND hWnd ){
ImmSimulateHotKey( hWnd, IME_CHOTKEY_SYMBOL_TOGGLE );
}
void CIme::ConvertCandList( CANDIDATELIST *pCandList, char *pszCandList ){
unsigned int i;
if( pCandList->dwCount < pCandList->dwSelection ){
pszCandList[ 0 ] = 0;
return;
}
for( i = 0; ( i < pCandList->dwCount - pCandList->dwSelection )&&( i < pCandList->dwPageSize ); i++ ){
*pszCandList++ = ( i % 10 != 9 )? i % 10 + '1' : '0';
*pszCandList++ = '.';
strcpy( pszCandList, (char*)pCandList
+ pCandList->dwOffset[ pCandList->dwSelection + i ] );
pszCandList += strlen( pszCandList );
*pszCandList++ = '\t';
}
*( pszCandList - 1 )= 0;
}
bool CIme::OnWM_INPUTLANGCHANGEREQUEST(){
return !g_bIme;
}
bool CIme::OnWM_INPUTLANGCHANGE( HWND hWnd ){
HKL hKL = GetKeyboardLayout( 0 );
if( ImmIsIME( hKL )){
HIMC hIMC = ImmGetContext( hWnd );
ImmEscape( hKL, hIMC, IME_ESC_IME_NAME, g_szImeName );
DWORD dwConversion, dwSentence;
ImmGetConversionStatus( hIMC, &dwConversion, &dwSentence );
g_bImeSharp = ( dwConversion & IME_CMODE_FULLSHAPE )? true : false;
g_bImeSymbol = ( dwConversion & IME_CMODE_SYMBOL )? true : false;
ImmReleaseContext( hWnd, hIMC );
}
else
g_szImeName[ 0 ] = 0;
return false;
}
bool CIme::OnWM_IME_NOTIFY( HWND hWnd, WPARAM wParam ){
HIMC hIMC;
DWORD dwSize;
DWORD dwConversion, dwSentence;
switch( wParam ){
case IMN_SETCONVERSIONMODE:
hIMC = ImmGetContext( hWnd );
ImmGetConversionStatus( hIMC, &dwConversion, &dwSentence );
g_bImeSharp = ( dwConversion & IME_CMODE_FULLSHAPE )? true : false;
g_bImeSymbol = ( dwConversion & IME_CMODE_SYMBOL )? true : false;
ImmReleaseContext( hWnd, hIMC );
break;
case IMN_OPENCANDIDATE:
case IMN_CHANGECANDIDATE:
hIMC = ImmGetContext( hWnd );
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
if( dwSize = ImmGetCandidateList( hIMC, 0, NULL, 0 )){
g_lpCandList = (LPCANDIDATELIST)GlobalAlloc( GPTR, dwSize );
if( g_lpCandList )
ImmGetCandidateList( hIMC, 0, g_lpCandList, dwSize );
}
ImmReleaseContext( hWnd, hIMC );
if( g_lpCandList )ConvertCandList( g_lpCandList, g_szCandList );
break;
case IMN_CLOSECANDIDATE:
if( g_lpCandList ){
GlobalFree( (HANDLE)g_lpCandList );
g_lpCandList = NULL;
}
g_szCandList[ 0 ] = 0;
break;
}
return true;
}
bool CIme::OnWM_IME_COMPOSITION( HWND hWnd, LPARAM lParam ){
HIMC hIMC;
DWORD dwSize;
hIMC = ImmGetContext( hWnd );
if( lParam & GCS_COMPSTR ){
dwSize = ImmGetCompositionString( hIMC, GCS_COMPSTR, (void*)g_szCompStr, sizeof( g_szCompStr ));
g_szCompStr[ dwSize ] = 0;
}
if( lParam & GCS_COMPREADSTR ){
dwSize = ImmGetCompositionString( hIMC, GCS_COMPREADSTR, (void*)g_szCompReadStr, sizeof( g_szCompReadStr ));
g_szCompReadStr[ dwSize ] = 0;
}
if( lParam & GCS_CURSORPOS ){
g_nImeCursor = 0xffff & ImmGetCompositionString( hIMC, GCS_CURSORPOS, NULL, 0 );
}
if( lParam & GCS_RESULTSTR ){
unsigned char str[ MAX_PATH ];
dwSize = ImmGetCompositionString( hIMC, GCS_RESULTSTR, (void*)str, sizeof( str ));
str[ dwSize ] = 0;
unsigned char *p = str;
while( *p )PostMessage( hWnd, WM_CHAR, (WPARAM)(*p++), 1 );
}
ImmReleaseContext( hWnd, hIMC );
return true;
}
char* CIme::GetImeName(){
return g_szImeName[ 0 ]? g_szImeName : NULL;
}
bool CIme::IfImeSharp(){
return g_bImeSharp;
}
bool CIme::IfImeSymbol(){
return g_bImeSymbol;
}
void CIme::GetImeInput( char **pszCompStr, char **pszCompReadStr, int *pnImeCursor, char **pszCandList ){
if( pszCompStr )*pszCompStr = g_szCompStr;
if( pszCompReadStr )*pszCompReadStr = g_szCompReadStr;
if( pnImeCursor )*pnImeCursor = g_nImeCursor;
if( pszCandList )*pszCandList = g_szCandList;
}
| C++ |
#if !defined(AFX_IM_H__6887B165_972D_4D17_8A75_FE07930CE59C__INCLUDED_)
#define AFX_IM_H__6887B165_972D_4D17_8A75_FE07930CE59C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define _CIM_MAXINPUTCHARNUMBER 24
#pragma comment ( lib, "imm32.lib" )
#include <windows.h>
class CIM
{
private:
LPCANDIDATELIST m_lpCandList;
LPSTR m_lpszImeInput;
LPSTR m_lpszCurInputLanguageDesc;
char m_cCandidateList[255];
char m_cInput[64];
BOOL CandidateToString( LPCANDIDATELIST lpCandidateList );
public:
CIM();
virtual ~CIM();
LPSTR GetResultString( void );
void UpdateShow( );
LPSTR GetCurInputLanguageDesc( );
void ClearCandidateList( void );
BOOL GetCandidateList( HWND hWnd );
BOOL ImeIsOpen( void );
void OnChar( TCHAR ch );
void OnImeNotify( HWND hWnd,WPARAM wParam );
void OnImeComposition( HWND hWnd, LPARAM lParam );
};
#endif
| C++ |
#include "im.h"
CIM::CIM()
{
m_lpszImeInput = new char[_CIM_MAXINPUTCHARNUMBER];
ZeroMemory( m_lpszImeInput,_CIM_MAXINPUTCHARNUMBER );
*m_lpszImeInput = '\0';
*m_cInput = '\0';
}
CIM::~CIM()
{
ZeroMemory( m_lpszImeInput,_CIM_MAXINPUTCHARNUMBER );
}
void CIM::OnImeComposition(HWND hWnd, LPARAM lParam)
{
if (lParam & GCS_RESULTSTR)
{
DWORD dwLen;
LPSTR lpResultStr;
HIMC hIMC = ImmGetContext(hWnd);
if (!hIMC)
return;
dwLen = ImmGetCompositionString(hIMC,GCS_RESULTSTR,NULL,0L);
dwLen+=1;
if(dwLen)
{
lpResultStr = new char[ dwLen ];
if( strlen( m_lpszImeInput ) + dwLen > _CIM_MAXINPUTCHARNUMBER - 2 )
{
MessageBeep( 0 );
return;
}
ZeroMemory( lpResultStr ,dwLen );
if (lpResultStr)
{
ImmGetCompositionString(hIMC,GCS_RESULTSTR, lpResultStr,dwLen);
strcat( m_lpszImeInput,lpResultStr );
}
delete lpResultStr;
}
ImmReleaseContext(hWnd,hIMC);
}
}
void CIM::OnImeNotify(HWND hWnd, WPARAM wParam)
{
DWORD dwCommand = (DWORD) wParam;
switch( dwCommand )
{
case IMN_CHANGECANDIDATE:
GetCandidateList( hWnd );
break;
case IMN_CLOSECANDIDATE:
break;
case IMN_OPENCANDIDATE:
GetCandidateList( hWnd );
break;
}
}
void CIM::OnChar( TCHAR ch )
{
int len = strlen( m_lpszImeInput );
if( ImeIsOpen() )
{
}
else
{
if( ch >= 32 && ch < 128 && len < _CIM_MAXINPUTCHARNUMBER - 1 )
{
*( m_lpszImeInput + len ) = ch;
*( m_lpszImeInput + len + 1) = '\0';
}
}
if( ch == 8 )
{
if( len == 0 )
return;
if( len == 1 )
{
*m_lpszImeInput = '\0';
return;
}
BYTE cc1,cc2;
cc1 = *(m_lpszImeInput + len -1);
cc2 = *(m_lpszImeInput + len -2);
if( cc1 > 0xA0 && cc2 > 0xA0 )
*( m_lpszImeInput + len -2 ) = '\0';
else
*( m_lpszImeInput + len -1 ) = '\0';
}
}
BOOL CIM::GetCandidateList(HWND hWnd)
{
DWORD dwSize;
HIMC hIMC;
ZeroMemory( m_cCandidateList,sizeof(m_cCandidateList) );
if( m_lpCandList )
{
delete m_lpCandList;
m_lpCandList = NULL;
}
if( GetKeyboardLayout(0)==0 )
{
return FALSE;
}
hIMC = ImmGetContext(hWnd);
if(hIMC == NULL)
{
return FALSE;
}
ZeroMemory( m_cCandidateList,sizeof(m_cCandidateList) );
if(dwSize = ImmGetCandidateList(hIMC,0x0,NULL,0))
{
m_lpCandList = (LPCANDIDATELIST)new char[dwSize];
if(m_lpCandList)
{
ImmGetCandidateList(hIMC,0x0,m_lpCandList,dwSize);
CandidateToString(m_lpCandList);
}
}
ImmReleaseContext(hWnd,hIMC);
return TRUE;
}
void CIM::ClearCandidateList()
{
if(m_lpCandList)
{
delete m_lpCandList;
m_lpCandList = NULL;
}
ZeroMemory( m_cCandidateList,sizeof( m_cCandidateList ) );
}
LPSTR CIM::GetCurInputLanguageDesc()
{
HKL hKL = GetKeyboardLayout(0);
int lengh = ImmGetDescription(hKL,NULL,0);
return m_lpszCurInputLanguageDesc;
}
void CIM::UpdateShow()
{
POINT pt;
pt.y = 450;
pt.x = 400;
pt.y = 420;
pt.x = 20;
pt.y = 450;
pt.x = 20;
if( *m_lpszImeInput == '\0' )
return;
}
LPSTR CIM::GetResultString()
{
return m_lpszImeInput;
}
BOOL CIM::CandidateToString(LPCANDIDATELIST lpCandidateList)
{
if( !m_lpCandList )
return FALSE;
if( m_lpCandList->dwCount>0 )
{
LPDWORD lpdwOffset;
lpdwOffset = &m_lpCandList->dwOffset[0];
lpdwOffset += m_lpCandList->dwPageStart;
ZeroMemory( m_lpCandList,sizeof( m_lpCandList ) );
DWORD z=1;
for (DWORD i = m_lpCandList->dwPageStart; (i < lpCandidateList->dwCount) && (i < m_lpCandList->dwPageStart + m_lpCandList->dwPageSize); i++)
{
LPSTR lpstr = (LPSTR)m_lpCandList + *lpdwOffset++;
char buf[255];
z++;
}
return TRUE;
}
return FALSE;
}
BOOL CIM::ImeIsOpen()
{
return ImmIsIME( GetKeyboardLayout(0) );
}
| C++ |
#if !defined(AFX_TOTUORIAL_H__DB41A13D_1745_4B62_BF85_9344651C32DF__INCLUDED_)
#define AFX_TOTUORIAL_H__DB41A13D_1745_4B62_BF85_9344651C32DF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define MAX_NUMBER_OF_SCRIPT_VARIABLE 100
#define MAX_NUMBER_OF_SCRIPT_PROCEDURE 100
#define MAX_CLIENT_SCRIPT_COUNT 30
#define MAX_CLIENT_SCRIPT_BUFFER_SIZE 4000
#define MAX_SCRIPT_VAR 100
enum CS_EVENT
{
CS_WAIT,
CS_RUN
};
struct sCS_FUNC
{
int (*pFunc)(void* pc,int* pParam);
int argCount;
};
typedef struct
{
int Type;
char ScriptData [MAX_CLIENT_SCRIPT_BUFFER_SIZE];
CS_EVENT ScriptEvent;
unsigned int saveTime;
int thinkTime;
int ScriptAddr;
int ScriptVariable [MAX_NUMBER_OF_SCRIPT_VARIABLE];
int ScriptProcedureAddr [MAX_NUMBER_OF_SCRIPT_PROCEDURE];
int callProcedureAddr;
bool isCall;
int msgWaiting;
int pcReplyIdx;
int msgFlag;
int sendMsgIdx;
int replyMsgIdxNumber;
int replyMsgIdx[5];
} ClientScript_t;
enum TIP_TYPES
{
TIP_INTERFACE = 0 ,
TIP_INVENTORY ,
TIP_CHAR_WINDOW ,
TIP_QUEST_WINDOW ,
TIP_PARTY_WINDOW ,
TIP_COMMAND_WINDOW ,
TIP_TRADE_WINDOW ,
TIP_ENERGY_PACK ,
TIP_SPELL ,
TIP_SECRET_TALK ,
TIP_PARTY_TALK ,
TIP_QUEST_NPC ,
TIP_REPAIRITEM ,
TIP_NSE ,
TIP_SKILL_POINT ,
TIP_GEN ,
TIP_STATUS_POINT ,
TIP_REPAIR_ITEM ,
TIP_COUNT
};
enum TutorialQuests
{
Tutorial_Walk = 0 ,
Tutorial_OpenInvenTory ,
Tutorial_TakeItem ,
Tutorial_MoveCamera ,
Tutorial_SitDown ,
Tutorial_SetTarget ,
Tutorial_Shopkeeper ,
Tutorial_MeetNpc ,
Tutorial_Count ,
};
enum ScriptType
{
TutorialScript,
TipScript
};
struct sTutorial_Script
{
int TutorialType;
ClientScript_t Script;
};
struct sTutorual_SaveBaseInfo
{
int CharIdx;
char Charname[256];
int TutorialNum;
bool bTutorialMode;
};
struct sTutorial_History
{
char LoginName[256];
vector <sTutorual_SaveBaseInfo> vBaseInfo;
};
class CTutorialMng
{
protected:
CFileMng *m_fileMng;
public:
int m_NowTutorialNum;
int m_NowTipNum;
protected:
bool m_bAlwaysRun;
static bool m_bTutorialMode;
int m_CompleteTutorial;
int m_Tip_Count;
int m_Tutorial_Count;
int m_LogInIdx;
public:
int ScriptVar [MAX_SCRIPT_VAR];
int QuestNumber;
protected:
sTutorial_Script m_Tip_Script [MAX_CLIENT_SCRIPT_COUNT];
sTutorial_Script m_Tutorial_Script [MAX_CLIENT_SCRIPT_COUNT];
public:
void SetCompleteTutorial (int type);
BOOL IsCompleteTutorial (int type);
void SetFileMng (CFileMng* mng ) { m_fileMng = mng;}
void SetReplyMessage (int reply);
void SettingTutorial (int idx);
bool GetTotutirlMode() {return m_bTutorialMode; }
void SetTotutirlMode (int active);
public:
BOOL Initialize ();
BOOL InitScript (int type, int idx);
BOOL LoadScriptFile (int Type, int idx, char* Filename);
bool SaveHistory (char *filename);
bool LoadHistory (char *filename);
BOOL Process();
vector<sTutorial_History> m_vTutorialHistory;
int FindInLoginID (char *ID);
int FindInCharName (int idx , char *Name);
public:
CTutorialMng();
~CTutorialMng(){};
};
void CS_LoadScript ( ClientScript_t* pCS, char* filename );
int CS_InterpretorFunction ( ClientScript_t* pCS );
int CS_InterpretorDefine ( ClientScript_t* pCS, int paramAddr );
char CS_GetCharData ( ClientScript_t* pCS );
int CS_GetIntData ( ClientScript_t* pCS );
int CS_Interpretor ( ClientScript_t* pCS );
void CS_InterpretorCall ( ClientScript_t* pCS );
void CS_InterpretorOperation ( ClientScript_t* pCS );
void CS_InterpretorParameter ( ClientScript_t* pCS, int param[], int n );
int CS_InterpretorCase ( ClientScript_t* pCS );
void CS_InterpretorThen ( ClientScript_t* pCS, int addrInfo[] );
void CS_InterpretorElse ( ClientScript_t* monster, int addrInfo[] );
void CS_InterpretorIF ( ClientScript_t* pCS );
int CS_IsMessageWating ( void *pPc, int *pParam );
int CS_SendMessage ( void *pPc, int *pParam );
int CS_SendMessageButton ( void *pPc, int *pParam );
int CS_GetMessageSelect ( void *pPc, int *pParam );
int CS_CloseMessage ( void *pPc, int *pParam );
int CS_GetPcEvent ( void *pPc, int *pParam );
int CS_SetQuestStep ( void *pPc, int *pParam );
int CS_CheckQuestStep ( void *pPc, int *pParam );
int CS_GetTutorialNum ( void *pPC, int *pParam );
int CS_SetTutorialNum ( void *pPC, int *pParam );
int CS_ChkOpenInvenWindow ( void *pPC, int *pParam );
int CS_ChkEquipItem ( void *pPc, int *pParam );
int CS_ChkMoveCamera ( void *pPc, int *pParam );
int CS_IsSelectObject ( void *pPc, int *pParam );
int CS_IsRequestNpcMenu ( void *pPc, int *pParam );
int CS_EndTutorial ( void *pPc, int *pParam );
int CS_IsOpenSkillWindow ( void *pPc, int *pParam );
int CS_ChkRegSitDownIcon ( void *pPc, int *pParam );
int CS_SEND_CHAT_MESSAGE (void *pPc, int *pParam);
int CS_SendMessage_TutorialMessage(int type, ClientScript_t* pCS );
extern sCS_FUNC CS_FUNC[];
#endif
| C++ |
#include "../global_def.h"
bool CTutorialMng::m_bTutorialMode = 0;
int CS_InterpretorFunction( ClientScript_t* pCS )
{
int param[5];
int variable = false;
int paramAddr;
int argCount;
paramAddr = CS_GetCharData( pCS );
argCount = CS_FUNC[paramAddr].argCount;
if ( argCount > 0 )
CS_InterpretorParameter( pCS, param, argCount );
variable = CS_FUNC[paramAddr].pFunc( pCS, param );
return( variable );
}
int CS_InterpretorDefine( ClientScript_t* pCS, int paramAddr )
{
int variable;
switch( paramAddr )
{
case 0 :
variable = true;
break;
case 1 :
variable = false;
break;
case 2:
variable = GTH_EV_CHAR_MOUSEWALK;
break;
case 3:
variable = GTH_EV_CHAR_MOUSERUN;
break;
case 4:
variable = GTH_EV_CHAR_SIT;
break;
case 5:
variable = 1;
break;
case 6:
variable = 2;
break;
case 7:
variable = 3;
break;
case 8:
variable = 4;
break;
case 9:
variable = 5;
break;
}
return( variable );
}
void CS_LoadScript( ClientScript_t* pCS, char* filename )
{
FILE *fp;
int n, l, type, var, i;
char name[128];
fp = fopen( filename, "rb" );
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &type, sizeof( int ), 1, fp );
fread( &var, sizeof( int ), 1, fp );
pCS->ScriptVariable[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
for( i = 0; i < n; i ++ )
{
fread( &l, sizeof( int ), 1, fp );
fread( name, l, 1, fp );
fread( &var, sizeof( int ), 1, fp );
pCS->ScriptProcedureAddr[ i ] = var;
}
fread( &n, sizeof( int ), 1, fp );
fread( pCS->ScriptData, n, 1, fp );
fclose( fp );
pCS->ScriptAddr = 0;
pCS->callProcedureAddr = 0;
pCS->isCall = false;
}
void CS_LoadScript( ClientScript_t* pCS, BYTE* FilePointer)
{
int n, l, type, var;
char name[128];
BYTE* pTempFile = FilePointer;
memcpy ( &n , pTempFile, sizeof ( int ) );
pTempFile += sizeof ( int );
for( int i = 0; i < n; i ++ )
{
memcpy ( &l, pTempFile, sizeof ( int ) );
pTempFile+= sizeof ( int );
memcpy ( &name, pTempFile, l );
pTempFile += l;
memcpy ( &type, pTempFile, sizeof ( int ) );
pTempFile+= sizeof ( int );
memcpy ( &var, pTempFile, sizeof ( int ) );
pTempFile+= sizeof ( int );
pCS->ScriptVariable[ i ] = var;
}
memcpy ( &n, pTempFile, sizeof ( int ) );
pTempFile+= sizeof ( int );
for( i = 0; i < n; i ++ )
{
memcpy ( &l, pTempFile, sizeof ( int ) );
pTempFile += sizeof ( int );
memcpy ( &name, pTempFile, l );
pTempFile+= l;
memcpy ( &var, pTempFile, sizeof ( int ) );
pTempFile+= sizeof ( int );
pCS->ScriptProcedureAddr[ i ] = var;
}
memcpy ( &n, pTempFile, sizeof ( int ) );
pTempFile += sizeof ( int );
memcpy ( &pCS->ScriptData, pTempFile, n);
pTempFile += n;
pCS->ScriptAddr = 0;
pCS->callProcedureAddr = 0;
pCS->isCall = false;
}
char CS_GetCharData( ClientScript_t* pCS )
{
return( pCS->ScriptData [ pCS->ScriptAddr++ ] );
}
int CS_GetIntData( ClientScript_t* pCS )
{
int n;
memcpy( &n, &pCS->ScriptData[ pCS->ScriptAddr ], sizeof( int ) );
pCS->ScriptAddr += sizeof( int );
return( n );
}
int CS_Interpretor( ClientScript_t* pCS )
{
char inter;
if( pCS->isCall )
{
pCS->isCall = false;
}
pCS->callProcedureAddr = pCS->ScriptAddr;
while( !pCS->isCall )
{
inter = CS_GetCharData( pCS );
if( inter == 'x' ) break;
switch( inter )
{
case 'p':
inter = CS_GetCharData( pCS );
break;
case 'o':
CS_InterpretorOperation( pCS );
break;
case 'i':
CS_InterpretorIF( pCS );
break;
case 'c':
CS_InterpretorCall( pCS );
break;
case 'f':
CS_InterpretorFunction( pCS );
}
}
pCS->ScriptAddr = pCS->callProcedureAddr;
return(1);
}
void CS_InterpretorCall( ClientScript_t* pCS )
{
int paramAddr;
paramAddr = CS_GetCharData( pCS );
if( pCS->isCall ) return;
pCS->callProcedureAddr = pCS->ScriptProcedureAddr[paramAddr];
pCS->isCall = true;
}
void CS_InterpretorOperation( ClientScript_t* pCS )
{
char inter;
int paramAddr1, paramAddr2, operatorParam;
int variable;
inter = CS_GetCharData( pCS );
if( inter == 'v' )
{
paramAddr1 = CS_GetCharData( pCS );
}
inter = CS_GetCharData( pCS );
operatorParam = inter;
inter = CS_GetCharData( pCS );
if( inter == 'v' )
{
paramAddr2 = CS_GetCharData( pCS );
variable = pCS->ScriptVariable[paramAddr2];
}
if( inter == 'n' )
{
variable = CS_GetIntData( pCS );
}
if( inter == 'f' )
{
variable = CS_InterpretorFunction( pCS );
}
if( inter == 'd' )
{
paramAddr2 = CS_GetCharData( pCS );
variable = CS_InterpretorDefine( pCS, paramAddr2 );
}
switch( operatorParam )
{
case 0:
pCS->ScriptVariable[paramAddr1] += variable;
break;
case 1:
pCS->ScriptVariable[paramAddr1] -= variable;
break;
case 2:
pCS->ScriptVariable[paramAddr1] *= variable;
break;
case 3:
pCS->ScriptVariable[paramAddr1] /= variable;
break;
case 4:
pCS->ScriptVariable[paramAddr1] = variable;
break;
}
}
void CS_InterpretorParameter( ClientScript_t* pCS, int param[], int n )
{
char inter;
int variable, paramAddr;
int i;
for( i = 0; i < n; i ++ )
{
inter = CS_GetCharData( pCS );
if( inter == 'n' )
{
variable = CS_GetIntData( pCS );
param[ i ] = variable;
continue;
}
if( inter == 'd' )
{
paramAddr = CS_GetCharData( pCS );
variable = CS_InterpretorDefine( pCS, paramAddr );
param[ i ]= variable;
continue;
}
if( inter == 'v' )
{
paramAddr = CS_GetCharData( pCS );
variable = pCS->ScriptVariable[paramAddr];
param[ i ] = variable;
continue;
}
if( inter == 'f' )
{
paramAddr = CS_GetCharData( pCS );
variable = CS_InterpretorFunction( pCS );
param[ i ] = variable;
continue;
}
}
}
int CS_InterpretorCase( ClientScript_t* pCS )
{
char inter;
int cases[5], casesNumber = 0;
int variable1, variable2, paramAddr, operatorAddr;
int i;
while( !pCS->isCall )
{
inter = CS_GetCharData( pCS );
if( inter == 't' ) break;
if( inter == 'a' ) inter = CS_GetCharData( pCS );
if( inter == 'v' )
{
paramAddr = CS_GetCharData( pCS );
variable1 = pCS->ScriptVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable1 = CS_GetIntData( pCS );
}
if( inter == 'd' )
{
paramAddr = CS_GetCharData( pCS );
variable1 = CS_InterpretorDefine( pCS, paramAddr );
}
if( inter == 'f' )
{
variable1 = CS_InterpretorFunction( pCS );
}
inter = CS_GetCharData( pCS );
operatorAddr = inter;
inter = CS_GetCharData( pCS );
if( inter == 'v' )
{
paramAddr = CS_GetCharData( pCS );
variable2 = pCS->ScriptVariable[ paramAddr ];
}
if( inter == 'n' )
{
variable2 = CS_GetIntData( pCS );
}
if( inter == 'd' )
{
paramAddr = CS_GetCharData( pCS );
variable2 = CS_InterpretorDefine( pCS, paramAddr );
}
if( inter == 'f' )
{
variable2 = CS_InterpretorFunction( pCS );
}
cases[ casesNumber ] = 0;
switch( operatorAddr )
{
case 0:
if( variable1 == variable2 ) cases[ casesNumber ] = 1;
break;
case 1:
if( variable1 != variable2 ) cases[ casesNumber ] = 1;
break;
case 2:
if( variable1 < variable2 ) cases[ casesNumber ] = 1;
break;
case 3:
if( variable1 > variable2 ) cases[ casesNumber ] = 1;
break;
case 4:
if( variable1 <= variable2 ) cases[ casesNumber ] = 1;
break;
case 5:
if( variable1 >= variable2 ) cases[ casesNumber ] = 1;
break;
}
casesNumber ++;
}
for( i = 0; i < casesNumber; i ++ ) if( !cases[ i ] ) return( 0 );
return( 1 );
}
void CS_InterpretorThen( ClientScript_t* pCS, int addrInfo[] )
{
char inter;
pCS->ScriptAddr = addrInfo[0];
while( !pCS->isCall )
{
inter = CS_GetCharData( pCS );
if( inter == 'e' || inter == 'q' )
{
pCS->ScriptAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
CS_InterpretorOperation( pCS );
break;
case 'i':
CS_InterpretorIF( pCS );
break;
case 'c':
CS_InterpretorCall( pCS );
break;
case 'f':
CS_InterpretorFunction( pCS );
break;
}
}
}
void CS_InterpretorElse( ClientScript_t* pCS, int addrInfo[] )
{
char inter;
pCS->ScriptAddr = addrInfo[1];
while( !pCS->isCall )
{
inter = CS_GetCharData( pCS );
if( inter == 'q' )
{
pCS->ScriptAddr = addrInfo[ 2 ];
break;
}
switch( inter )
{
case 'o':
CS_InterpretorOperation( pCS );
break;
case 'i':
CS_InterpretorIF( pCS );
break;
case 'c':
CS_InterpretorCall( pCS );
break;
case 'f':
CS_InterpretorFunction( pCS );
break;
}
}
}
void CS_InterpretorIF( ClientScript_t* pCS )
{
char inter;
int addrInfo[3];
int cases;
addrInfo[0] = CS_GetIntData( pCS );
addrInfo[1] = CS_GetIntData( pCS );
addrInfo[2] = CS_GetIntData( pCS );
while( !pCS->isCall )
{
inter = CS_GetCharData( pCS );
if( inter == 'q' ) break;
if( inter == 'a' )
{
cases = CS_InterpretorCase( pCS );
if( cases ) CS_InterpretorThen( pCS, addrInfo );
else if( addrInfo[1] ) CS_InterpretorElse( pCS, addrInfo );
else pCS->ScriptAddr = addrInfo[ 2 ];
}
}
}
char *TutorialFilenames[] =
{
"Tutorial.ss",
};
char *TipFilenames[] =
{
"Tutorial.ss",
};
#define TutorialFileCount 1
#define TipFileCount 0
CTutorialMng::CTutorialMng()
{
m_fileMng = NULL;
m_NowTipNum = -1;
}
void CTutorialMng::SetCompleteTutorial (int type)
{
m_CompleteTutorial |= 1 << type ;
}
BOOL CTutorialMng::IsCompleteTutorial (int type)
{
int temp = 1 << type;
return temp & m_CompleteTutorial;
}
int CTutorialMng::FindInCharName(int idx, char *name)
{
for (int i =0 ; i <m_vTutorialHistory[idx].vBaseInfo.size(); i++)
{
if ( !strcmp(m_vTutorialHistory[idx].vBaseInfo[i].Charname, name) )
return i;
}
return -1;
}
int CTutorialMng::FindInLoginID(char *id)
{
for (int i = 0; i < m_vTutorialHistory.size(); i ++)
{
if ( !strcmp (m_vTutorialHistory[i].LoginName, id))
return i;
}
return -1;
}
bool CTutorialMng::SaveHistory (char *filename)
{
return 0;
FILE *pFile = NULL;
pFile = fopen(filename,"wb");
if ( pFile == NULL ) return 0;
int nameIdx = -1;
m_LogInIdx = FindInLoginID(g_cgv.clientID);
if ( m_LogInIdx >= 0 )
{
nameIdx = FindInCharName(m_LogInIdx, g_cgv.myCharacterInfo->name);
if (nameIdx >= 0 )
{
m_vTutorialHistory[m_LogInIdx].vBaseInfo[nameIdx].TutorialNum = m_NowTutorialNum;
m_vTutorialHistory[m_LogInIdx].vBaseInfo[nameIdx].bTutorialMode = m_bTutorialMode;
}
else
{
sTutorual_SaveBaseInfo SaveBaseInfo;
SaveBaseInfo.bTutorialMode = m_bTutorialMode;
SaveBaseInfo.CharIdx = g_cgv.myCharacterInfo->characterID;
memset(SaveBaseInfo.Charname, 0, 256);
strcpy( SaveBaseInfo.Charname, g_cgv.myCharacterInfo->name);
SaveBaseInfo.TutorialNum = m_NowTutorialNum;
m_vTutorialHistory[m_LogInIdx].vBaseInfo.push_back(SaveBaseInfo);
}
}
else
{
sTutorial_History history;
strcpy(history.LoginName, g_cgv.clientID);
sTutorual_SaveBaseInfo SaveBaseInfo;
SaveBaseInfo.bTutorialMode = m_bTutorialMode;
SaveBaseInfo.CharIdx = g_cgv.myCharacterInfo->characterID;
memset(SaveBaseInfo.Charname, 0, 256);
strcpy( SaveBaseInfo.Charname, g_cgv.myCharacterInfo->name);
SaveBaseInfo.TutorialNum = m_NowTutorialNum;
history.vBaseInfo.push_back(SaveBaseInfo);
m_vTutorialHistory.push_back(history);
}
int size = m_vTutorialHistory.size();
fwrite(&size, sizeof(int), 1, pFile);
for (int i = 0; i < m_vTutorialHistory.size(); i ++)
{
fwrite(m_vTutorialHistory[i].LoginName, 256, 1, pFile);
int size = m_vTutorialHistory[i].vBaseInfo.size();
fwrite(&size, sizeof(int), 1, pFile);
for (int o = 0; o <m_vTutorialHistory[i].vBaseInfo.size(); o++)
{
fwrite(&m_vTutorialHistory[i].vBaseInfo[o], sizeof ( sTutorual_SaveBaseInfo), 1, pFile);
}
}
fclose(pFile);
return 1;
}
bool CTutorialMng::LoadHistory (char *filename)
{
return 0;
FILE *pFile = NULL;
pFile = fopen(filename, "rb");
if (pFile == NULL ) return 0;
int size = m_vTutorialHistory.size();
fread(&size, sizeof(int), 1, pFile);
for (int i = 0; i < size; i ++)
{
sTutorial_History history;
fread(&history.LoginName, 256, 1, pFile);
int IdCount;
fread(&IdCount, sizeof(int), 1, pFile);
for (int o = 0; o <IdCount; o++)
{
sTutorual_SaveBaseInfo baseinfo;
fread(&baseinfo, sizeof (sTutorual_SaveBaseInfo), 1, pFile );
history.vBaseInfo.push_back(baseinfo);
}
m_vTutorialHistory.push_back(history);
}
int nameIdx = -1;
m_LogInIdx = FindInLoginID(g_cgv.clientID);
if ( m_LogInIdx >= 0 )
{
nameIdx = FindInCharName(m_LogInIdx, g_cgv.myCharacterInfo->name);
if ( nameIdx >= 0 )
{
m_NowTutorialNum = m_vTutorialHistory[m_LogInIdx].vBaseInfo[nameIdx].TutorialNum;
m_bTutorialMode = m_vTutorialHistory[m_LogInIdx].vBaseInfo[nameIdx].bTutorialMode;
}
}
fclose(pFile);
return 1;
}
BOOL CTutorialMng::Initialize()
{
if ( g_cgv.myCharacterInfo->level != 1 || g_cgv.myCharacterInfo->exp != 0)
{
m_CompleteTutorial = 1;
m_Tutorial_Count = 0;
m_Tip_Count = 0;
m_bAlwaysRun = 0;
m_bTutorialMode = 0;
QuestNumber = 0;
m_NowTutorialNum = -1;
m_bTutorialMode = 0;
return 0;
}
if (m_bTutorialMode)
{
int Idx = FindInLoginID(g_cgv.clientID);
if ( Idx == m_LogInIdx) return 1;
else
SaveHistory("history.his");
}
m_CompleteTutorial = 0;
m_Tutorial_Count = 0;
m_Tip_Count = 0;
m_bAlwaysRun = 0;
m_bTutorialMode = 1;
QuestNumber = 0;
m_NowTutorialNum = -1;
memset(ScriptVar, 0, MAX_SCRIPT_VAR);
for (int i = 0; i < TutorialFileCount; i ++)
{
memset (&m_Tutorial_Script[i], 0, sizeof (sTutorial_Script));
LoadScriptFile(TutorialScript, i, TutorialFilenames[i]);
}
for (i = 0; i < TipFileCount; i ++)
{
memset (&m_Tip_Script[i], 0, sizeof (sTutorial_Script));
LoadScriptFile(TipScript, i, TipFilenames[i]);
}
LoadHistory("history.his");
return 1;
}
void CTutorialMng::SettingTutorial(int idx)
{
if ( m_bAlwaysRun )
{
InitScript(TipScript, idx);
m_NowTipNum = idx;
}
else
{
if ( !IsCompleteTutorial(idx) )
{
InitScript(TipScript, idx);
m_NowTipNum = idx;
}
}
}
BOOL CTutorialMng::InitScript(int type, int idx)
{
sTutorial_Script* Script;
if ( type == TutorialScript )
Script = m_Tutorial_Script;
else
Script = m_Tip_Script;
Script[idx].Script.msgFlag = 0;
Script[idx].Script.isCall = false;
Script[idx].Script.callProcedureAddr = 0;
Script[idx].Script.msgWaiting = 0;
Script[idx].Script.pcReplyIdx = -1;
Script[idx].Script.ScriptEvent = CS_RUN;
Script[idx].Script.saveTime = 0;
Script[idx].Script.thinkTime = 0;
Script[idx].Script.msgWaiting = false;
Script[idx].Script.msgFlag = false;
Script[idx].Script.sendMsgIdx = 0;
Script[idx].Script.replyMsgIdxNumber = 0;
Script[idx].Script.replyMsgIdx[0] = 0;
Script[idx].Script.replyMsgIdx[1] = 0;
Script[idx].Script.replyMsgIdx[2] = 0;
Script[idx].Script.replyMsgIdx[3] = 0;
m_Tip_Script[idx].Script.replyMsgIdx[4] = 0;
return 1;
}
BOOL CTutorialMng::Process()
{
if ( m_bTutorialMode )
{
if ( m_Tutorial_Count > -1 && m_NowTutorialNum >= -1)
CS_Interpretor( &m_Tutorial_Script[0].Script );
CS_SendMessage_TutorialMessage ( TutorialScript, &m_Tutorial_Script[0].Script );
return 1;
}
return 0;
}
void CTutorialMng::SetReplyMessage(int replyidx)
{
m_Tutorial_Script[0].Script.pcReplyIdx = replyidx;
}
BOOL CTutorialMng::LoadScriptFile (int Type, int idx, char* Filename)
{
if ( !m_fileMng || !Filename) return 0;
BYTE *pFile = NULL;
pFile = m_fileMng->ReadFileFromPack(Filename);
sTutorial_Script* Script = NULL;
int* Count = 0;
if ( Type == TutorialScript )
{
Script = m_Tutorial_Script;
Count = &m_Tutorial_Count;
}
else
{
Script = m_Tip_Script;
Count = &m_Tip_Count;
}
if ( (*Count) < MAX_CLIENT_SCRIPT_COUNT )
{
Script[idx].TutorialType = 1 << idx;
CS_LoadScript(&Script[idx].Script, pFile);
(*Count)++ ;
}
else
return 0;
return 1;
}
int CS_SendMessage_TutorialMessage( int type, ClientScript_t* pCS )
{
if ( !pCS->msgFlag ) return 0;
if ( type == TipScript )
{
return 1;
}
else
{
if( pCS->sendMsgIdx < 0 ) return 0;
g_ifMng->m_tutorialWin->MakeMessage( pCS->sendMsgIdx );
for( int i = 0; i < pCS->replyMsgIdxNumber; i ++ )
g_ifMng->m_tutorialWin->MakeSelectMessage( i, pCS->replyMsgIdx[i] );
pCS->msgFlag = 0;
}
return 1;
}
void CTutorialMng::SetTotutirlMode (int active)
{
m_bTutorialMode = active;
};
| C++ |
#include "../global_def.h"
sCS_FUNC CS_FUNC[] =
{
{ CS_IsMessageWating , 0 },
{ CS_SendMessage , 1 },
{ CS_SendMessageButton , 2 },
{ CS_GetMessageSelect , 0 },
{ CS_CloseMessage , 0 },
{ CS_GetPcEvent , 1 },
{ CS_SetQuestStep , 2 },
{ CS_CheckQuestStep , 1 },
{ CS_GetTutorialNum , 1 },
{ CS_SetTutorialNum , 1 },
{ CS_ChkOpenInvenWindow , 0 },
{ CS_ChkEquipItem , 0 },
{ CS_ChkMoveCamera , 1 },
{ CS_IsSelectObject , 0 },
{ CS_IsRequestNpcMenu , 0 },
{ CS_EndTutorial , 0 },
{ CS_IsOpenSkillWindow , 0 },
{ CS_ChkRegSitDownIcon , 0 },
{ CS_SEND_CHAT_MESSAGE , 1 },
};
int CS_IsMessageWating( void* pPc, int *pParam )
{
ClientScript_t* pc = static_cast<ClientScript_t*>(pPc);
if( pc->msgWaiting ) return( true );
else return( false );
}
int CS_SendMessage( void* pPc, int *pParam )
{
ClientScript_t* pc = static_cast<ClientScript_t*>(pPc);
int idx = pParam[0];
pc->msgWaiting = true;
pc->msgFlag = true;
pc->sendMsgIdx = idx;
pc->pcReplyIdx = -1;
pc->replyMsgIdxNumber = 0;
g_ifMng->m_tutorialWin->InitHelp();
return( true );
}
int CS_SendMessageButton( void* pPc, int *pParam )
{
ClientScript_t *pc = static_cast<ClientScript_t*>(pPc);
int buttonType = pParam[0];
int idx = pParam[1];
if( buttonType + 1 > pc->replyMsgIdxNumber )
pc->replyMsgIdxNumber = buttonType + 1;
pc->replyMsgIdx[buttonType] = idx;
return( true );
}
int CS_GetMessageSelect( void* pPc, int *pParam )
{
ClientScript_t *pc = static_cast<ClientScript_t*>(pPc);
if( pc->pcReplyIdx >= 0 )
{
pc->msgWaiting = false;
return( pc->pcReplyIdx );
}
else return( -1 );
}
int CS_CloseMessage( void* pPc, int *pParam )
{
ClientScript_t *pc = static_cast<ClientScript_t*>(pPc);
g_TutorialMng->SetCompleteTutorial(g_TutorialMng->m_NowTutorialNum);
return( true );
}
int CS_GetPcEvent( void *pPc, int *pParam )
{
ClientScript_t *pc = static_cast<ClientScript_t*>(pPc);
if (pParam[0] == g_pApp->m_myCharacter->event )
{
pc->msgWaiting = false;
return 1;
}
return 0;
}
int CS_GetTutorialNum( void *pPC, int *pParam)
{
return ( pParam[0] == g_TutorialMng->m_NowTutorialNum );
}
int CS_SetTutorialNum( void *pPC, int *pParam)
{
return g_TutorialMng->m_NowTutorialNum = pParam[0];
}
int CS_ChkOpenInvenWindow( void *pPC, int *pParam)
{
return g_ifMng->m_itemWin->State();
}
int CS_SetQuestStep( void *pPc, int *pParam )
{
ClientScript_t* pc = static_cast< ClientScript_t* >( pPc );
int questNo = pParam[0];
int questStep = pParam[1];
g_TutorialMng->ScriptVar [ questNo ] = questStep;
pc->msgWaiting = FALSE;
return TRUE;
}
int CS_CheckQuestStep( void *pPc, int *pParam )
{
int questNo = pParam[0];
return g_TutorialMng->ScriptVar[ questNo ];
}
int CS_ChkEquipItem( void *pPc, int *pParam )
{
if ( g_cgv.myCharacterInfo->equipment[0] > -1|| g_cgv.myCharacterInfo->equipment[1] > -1 )
return 1;
return 0;
}
int CS_ChkMoveCamera( void *pPc, int *pParam)
{
switch ( pParam[0] )
{
case 1:
if ( g_input->KeyEvent( DIK_LEFT ) || g_input->KeyEvent( DIK_RIGHT ))
return 1;
break;
case 2:
if ( g_input->KeyEvent( DIK_UP ) || g_input->KeyEvent( DIK_DOWN ) )
return 1;
break;
case 3:
if ( g_input->KeyEvent( DIK_PRIOR ) || g_input->KeyEvent( DIK_NEXT ) )
return 1;
break;
case 4:
if ( g_input->m_isWheeled )
return 1;
break;
case 5:
if (g_input->GetMouseMode() == INPUT_MOUSE_SCROLL_MODE )
return 1;
break;
}
return 0;
}
int CS_IsSelectObject(void *pPc, int *pParam)
{
if ( g_cgv.pTargetChar == NULL ) return 0;
else if ( g_cgv.pTargetChar->entityType == ENTITY_MONSTER )
return 1;
return 0;
}
int CS_IsRequestNpcMenu(void *pPc, int *pParam)
{
if ( g_cgv.clickEvent == GTH_CEV_CHAR_NPC_REQUEST)
return 1;
return 0;
}
int CS_EndTutorial (void *pPc, int *pParam)
{
g_TutorialMng->SetTotutirlMode(false);
g_TutorialMng->SaveHistory("history.his");
return 1;
}
int CS_IsOpenSkillWindow (void *pPc, int *pParam)
{
return g_ifMng->m_skillWin->State();
}
int CS_ChkRegSitDownIcon (void *pPc, int *pParam)
{
for (int i = 0 ;i <MAX_NUMBER_OF_HOTKEY; i++ )
{
int hotIdx = g_cgv.myCharacterInfo->hotkeyIdx[i];
if( hotIdx < 0 ) continue;
if( g_cgv.myCharacterInfo->hotkeyType[i] == IF_HOTTYPE_ACTION)
{
if (g_actionTable[hotIdx].id == ACTION_SIT) return 1;
}
}
return 0;
}
int CS_SEND_CHAT_MESSAGE(void *pPc, int *pParam)
{
int idx = pParam[0];
g_ifMng->m_dlgWin->AddChatMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,idx) );
return 1;
}
| C++ |
enum
{
GTH_SOUND_ID_BUTTON_CLICK_1 = 0,
GTH_SOUND_ID_BUTTON_CLICK_2,
GTH_SOUND_ID_GEN_CLICK,
GTH_SOUND_ID_CHAR_CLICK,
GTH_SOUND_ID_OPEN_WINDOW,
GTH_SOUND_ID_CLOSE_WINDOW,
GTH_SOUND_ID_LOGIN_WINDOW,
GTH_SOUND_ID_LOGIN_WINDOW_2,
GTH_SOUND_ID_ITEM_CLICK_1,
GTH_SOUND_ID_ITEM_CLICK_2,
GTH_SOUND_ID_DROP_ITEM,
GTH_SOUND_ID_PICKUP_ITEM,
GTH_SOUND_ID_EQUIP_ITEM,
GTH_SOUND_ID_WARNING_1,
GTH_SOUND_ID_WARNING_2,
GTH_SOUND_ID_NOTICE,
GTH_SOUND_ID_DISAPPEAR_MON,
GTH_SOUND_ID_REPAIRWARNING,
GTH_SOUND_ID_LOGIN_WINDOW3,
GTH_SOUND_ID_LOGIN_BUTTONSHOW,
GTH_SOUND_ID_LOGIN_ITEMABSORB,
GTH_SOUND_ID_GAMELOGIN_OK,
GTH_SOUND_ID_REPAIR,
GTH_SOUND_ID_SPAWNFIELD_MON,
GTH_SOUND_ID_SPAWNDUN_MON,
GTH_SOUND_ID_SPAWN_ITEM,
GTH_SOUND_ID_PC_HEARTBEAT_0,
GTH_SOUND_ID_PC_HEARTBEAT_1,
GTH_SOUND_ID_PC_HEARTBEAT_2,
GTH_SOUND_ID_PC_RECOVERY_RA,
GTH_SOUND_ID_PC_RECOVERY_SA,
GTH_SOUND_ID_DISAPPEAR_MON2,
GTH_SOUND_ID_LEVELUP,
GTH_SOUND_ID_CHARSPAWN,
GTH_SOUND_ID_QUESTSCROLL_DROP,
GTH_SOUND_ID_QUESTSCROLL_WRITING,
GTH_SOUND_ID_BATTLE_COUNT,
GTH_SOUND_ID_CONG,
GTH_SOUND_ID_BATTLE_FAIL,
GTH_SOUND_ID_BATTLE_FIGHT,
GTH_SOUND_ID_BATTLE_READY,
GTH_SOUND_ID_BATTLE_SUCCESS,
GTH_SOUND_ID_BATTLE_READYFIGHT,
};
#define MAX_COUNT_GTH_PC_SOUND 8
#define MAX_COUNT_GTH_MONSTER_SOUND 400
#define MAX_COUNT_GTH_ITEM_SOUND 1000
#define MAX_COUNT_GTH_MDL_SOUND_ID 600
typedef struct
{
int idx;
char filename[128];
int numDup;
int is3D;
int soundID;
} gthSoundID_t;
typedef struct
{
gthSoundID_t normalID[128];
int numNoramlID;
gthSoundID_t itemID[128];
int numItemID;
gthSoundID_t eventID[MAX_ANIMCOUNT_TYPE][128];
int numEventID[MAX_ANIMCOUNT_TYPE];
} gthSoundResource_t;
typedef struct
{
int idx;
char mdlname [255];
char soundname [255];
} mdlSoundID_t;
typedef struct
{
int idx;
int soundID[MAX_ANIMCOUNT_TYPE];
float playTime[MAX_ANIMCOUNT_TYPE];
int frequency[MAX_ANIMCOUNT_TYPE];
int playCount[MAX_ANIMCOUNT_TYPE];
} monsterSound_t;
typedef struct
{
int idx;
int soundID[MAX_ANIMCOUNT_TYPE];
float playTime[MAX_ANIMCOUNT_TYPE];
int frequency[MAX_ANIMCOUNT_TYPE];
int playCount[MAX_ANIMCOUNT_TYPE];
} pcSound_t;
typedef struct
{
int idx;
int soundID;
float playTime;
} itemSound_t;
typedef struct
{
int idx;
int soundID;
} skillSound_t;
class CSoundMng
{
public:
gthSoundResource_t m_soundResource;
int m_maxIdx;
int m_nummdlSoundID;
mdlSoundID_t m_mdlSoundID [MAX_COUNT_GTH_MDL_SOUND_ID];
monsterSound_t m_monSound[MAX_COUNT_GTH_MONSTER_SOUND];
pcSound_t m_pcSound[MAX_COUNT_GTH_PC_SOUND];
itemSound_t m_itemSound[MAX_COUNT_GTH_ITEM_SOUND];
CSoundMng();
~CSoundMng();
void LoadSoundConfig( char* filename );
void LoadMDLSoundConfig ( char *in_filename );
void Initialize();
void Play( Fx_CHARACTER_t* character );
void PlayMonsterSound( Fx_CHARACTER_t* character );
void PlayCharSound( Fx_CHARACTER_t* character );
void PlayDamageSound( Fx_CHARACTER_t* character );
int GetNormalSoundID( int idx );
int GetItemSoundID( int idx );
int GetEventSoundID( int event, int idx );
};
inline void SetSample( char *name , int maxBuffers , int idxSample , int is3D );
void ConfigGameSamples();
void ConfigMDLSamples();
int GetGameSampleID( char *path );
| C++ |
#include "../global_def.h"
#ifdef _FMOD_SOUND
CSoundSample::CSoundSample()
{
memset( m_name, 0, sizeof( m_name ) );
m_idxSound = -1;
m_is3D = false;
m_isPlaying = false;
m_isLoaded = false;
m_channel = -1;
m_sample = NULL;
m_size = 0;
}
CSoundSample::~CSoundSample()
{
Dispose();
Clear();
}
bool CSoundSample::Create( char *fname, int iSize )
{
m_size = iSize;
strcpy( m_name, fname );
if( m_is3D )
{
m_sample = FSOUND_Sample_Load( FSOUND_FREE, m_name, FSOUND_HW3D | FSOUND_LOOP_OFF, 0, 0 );
FSOUND_Sample_SetMinMaxDistance( m_sample, 2.0f, 1500.0f );
}
else
{
m_sample = FSOUND_Sample_Load( FSOUND_FREE, m_name, FSOUND_2D | FSOUND_LOOP_OFF, 0, 0 );
}
if( m_sample ) return true;
return false;
}
bool CSoundSample::Recreate()
{
if( m_is3D )
{
m_sample = FSOUND_Sample_Load( FSOUND_FREE, m_name, FSOUND_HW3D | FSOUND_LOOP_OFF, 0, 0 );
FSOUND_Sample_SetMinMaxDistance( m_sample, 2.0f, 1500.0f );
}
else
{
m_sample = FSOUND_Sample_Load( FSOUND_FREE, m_name, FSOUND_2D | FSOUND_LOOP_OFF, 0, 0 );
}
if( m_sample ) return true;
return false;
}
CMusicMng::CMusicMng()
{
m_inited = false;
m_inited3D = false;
m_supporteax2 = false;
m_supporteax3 = false;
m_numSamples = 0;
m_numSounds = 0;
m_bBgm = true;
m_bEffect = true;
m_bEnable = true;
m_bgmVolume = 100;
m_effectVolume = 128;
m_bgHandle = -1;
m_BGMStream = NULL;
m_enabledState = false;
m_lockedState = false;
m_bgVolumePercentage = 100;
m_effectVolumePercentage = 100;
m_bgmDefaultVolume = 60;
m_effectDefaultVolume = 128;
memset( m_bgFilename, 0, sizeof( m_bgFilename ) );
}
CMusicMng::~CMusicMng()
{
ReleaseAllSamples();
}
int CMusicMng::Initialize( HWND in_hwnd )
{
if( !Enabled() ) return true;
unsigned int devcaps = 0;
if( FSOUND_GetVersion() < FMOD_VERSION )
{
m_inited = false;
m_inited3D = false;
return false;
}
FSOUND_SetHWND( in_hwnd );
FSOUND_SetOutput( FSOUND_OUTPUT_DSOUND );
FSOUND_SetDriver( 0 );
FSOUND_GetDriverCaps ( 0, &devcaps );
if( devcaps & FSOUND_CAPS_HARDWARE ) m_inited3D = true;
if( devcaps & FSOUND_CAPS_EAX2 ) m_supporteax2 = true;
if( devcaps & FSOUND_CAPS_EAX3 ) m_supporteax3 = true;
FSOUND_SetMixer( FSOUND_MIXER_AUTODETECT );
FSOUND_SetMinHardwareChannels( 4 );
FSOUND_SetMaxHardwareChannels( 32 );
FSOUND_3D_SetDistanceFactor( 1.0f );
FSOUND_3D_SetRolloffFactor( 0.75f );
if( !FSOUND_Init( 44100, 32, 0 ) )
{
m_bEnable = false;
m_inited = false;
m_inited3D = false;
return false;
}
m_bEnable = true;
m_inited = true;
FSOUND_Stream_SetBufferSize( 1000 );
ConfigGameSamples();
ConfigMDLSamples();
m_resManager.Create( 1024 * 1024 * 5 );
LoadSamples();
return true;
}
int CMusicMng::PlayBGMusic( char *in_musicName )
{
char error[MAX_PATH];
if( !Enabled() ) return true;
if( !m_bEnable ) return false;
if( !stricmp( m_bgFilename, in_musicName ) && m_bgHandle != -1 ) return true;
if( m_bgHandle != -1 ) StopBGMusic();
m_BGMStream = FSOUND_Stream_Open( in_musicName, FSOUND_NORMAL | FSOUND_MPEGACCURATE | FSOUND_LOOP_NORMAL, 0, 0 );
if( !m_BGMStream )
{
sprintf( error, "CMusicMng::PlayBGMusic - %s\n", FMOD_ErrorString ( FSOUND_GetError () ) );
CloseBGSample();
return false;
}
strcpy( m_bgFilename, in_musicName );
if( m_bBgm )
{
m_bgHandle = FSOUND_Stream_PlayEx( FSOUND_FREE, m_BGMStream, NULL, TRUE );
FSOUND_SetPaused( m_bgHandle, FALSE );
}
else
{
m_bgHandle = -1;
}
g_musicMng->RefreshBgmVolume();
g_musicMng->RefreshEffectVolume();
return true;
}
int CMusicMng::ChangeBGMusic( char *in_musicName )
{
PlayBGMusic( in_musicName );
return true;
}
void CMusicMng::StopBGMusic()
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
FSOUND_Stream_Stop( m_BGMStream );
FSOUND_Stream_Close( m_BGMStream );
m_bgHandle = -1;
}
void CMusicMng::SetBgm( bool bBgm )
{
if( !Enabled() ) return;
m_bBgm = bBgm;
if( !m_bEnable ) return;
if( m_bgHandle != -1 )
FSOUND_SetPaused( m_bgHandle, !m_bBgm );
if( m_bBgm )
{
if( m_bgHandle == -1 )
{
if ( m_BGMStream )
{
m_bgHandle = FSOUND_Stream_PlayEx( FSOUND_FREE, m_BGMStream, NULL, TRUE );
FSOUND_SetPaused( m_bgHandle, FALSE );
}
}
}
}
void CMusicMng::ReleaseAllSamples()
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
CloseBGSample();
for( int i = 0; i < MAX_SIZE_SOUND; i ++ )
{
if( !m_samples[i].m_isLoaded ) continue;
if( !m_samples[i].m_sample ) continue;
m_samples[i].Dispose();
}
}
void CMusicMng::Stop()
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
for( int i = 0; i < MAX_SIZE_SOUND; i ++ )
{
if( !m_samples [i].m_isLoaded ) continue;
if( !m_samples [i].m_sample ) continue;
Stop( i );
}
}
int CMusicMng::Stop( int in_index )
{
if( !Enabled() ) return true;
if( !m_bEnable ) return false;
if( !m_inited ) return true;
if( m_samples [in_index].m_sample )
FSOUND_StopSound( m_samples[in_index].m_channel );
return true;
}
void CMusicMng::CloseBGSample()
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
if( m_BGMStream )
{
FSOUND_Stream_Stop( m_BGMStream );
FSOUND_Stream_Close( m_BGMStream );
}
}
void CMusicMng::SetBGMusicVolume( int in_volume )
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
FSOUND_SetVolumeAbsolute( m_bgHandle, in_volume );
}
void CMusicMng::SetVolume( int in_masterVolume )
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
FSOUND_SetSFXMasterVolume( in_masterVolume );
}
void CMusicMng::UpdateListener( vec3_t position, vec3_t velocity, vec3_t orientation )
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
vec3_t convertPos;
convertPos[0] = position[0] / 100.0f;
convertPos[1] = 0.0f;
convertPos[2] = position[1] / 100.0f;
static vec3_t oldPos;
{
FSOUND_3D_Listener_SetAttributes ( &convertPos [0],
&velocity [0],
orientation [0], 0.0f, orientation [1],
0.0f, 1.0f, 0.0f );
oldPos[0] = convertPos[0];
oldPos[1] = convertPos[1];
oldPos[2] = convertPos[2];
}
}
int CMusicMng::IsPlaying( int idxSample )
{
if( !Enabled() ) return false;
if( !m_bEnable ) return false;
if( !m_samples[idxSample].m_isPlaying ) return false;
return true;
}
void CMusicMng::PlaySample( int idxSample, GTH_SOUND_PLAY_TYPE play )
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
if( !m_bEffect ) return;
if( !m_inited ) return;
vec3_t pos;
CSoundSample *thisSample = GetSample( idxSample );
if( !thisSample ) return;
if( !thisSample->m_isLoaded ) return;
VectorClear( pos );
if( thisSample->m_is3D && m_inited3D )
{
PlaySample3D ( idxSample, play, pos );
return;
}
if( IsPlaying( idxSample ) )
{
FSOUND_StopSound ( thisSample->m_channel );
}
thisSample->m_channel = FSOUND_PlaySound( FSOUND_FREE, thisSample->m_sample );
if( thisSample->m_channel < 0 ) thisSample->m_isPlaying = false;
else thisSample->m_isPlaying = true;
if( play == GTH_SOUND_PLAY_LOOP )
FSOUND_SetLoopMode( thisSample->m_channel, FSOUND_LOOP_NORMAL );
else
FSOUND_SetLoopMode( thisSample->m_channel, FSOUND_LOOP_OFF );
}
void CMusicMng::PlaySample3D( int idxSample, GTH_SOUND_PLAY_TYPE play, vec3_t pos )
{
if( !Enabled() ) return;
if( !m_bEnable ) return;
if( !m_bEffect ) return;
if( !m_inited ) return;
CSoundSample *thisSample = GetSample( idxSample );
vec3_t convertPos;
if( !thisSample ) return;
if( !thisSample->m_isLoaded ) return;
thisSample->m_channel = FSOUND_PlaySoundEx ( FSOUND_FREE, thisSample->m_sample, 0, TRUE );
if( thisSample->m_channel < 0 )
{
thisSample->m_isPlaying = false;
return;
}
convertPos[0] = pos[0] / 100.0f;
convertPos[1] = 0.0f;
convertPos[2] = pos[1] / 100.0f;
thisSample->m_isPlaying = true;
if( !FSOUND_3D_SetAttributes( thisSample->m_channel, convertPos, NULL ) )
{
char error[ MAX_PATH ];
sprintf( error, "%s\n", FMOD_ErrorString( FSOUND_GetError() ) );
OutputDebugString( error );
}
if( play == GTH_SOUND_PLAY_LOOP )
FSOUND_SetLoopMode( thisSample->m_channel, FSOUND_LOOP_NORMAL );
else
FSOUND_SetLoopMode( thisSample->m_channel, FSOUND_LOOP_OFF );
if( !FSOUND_SetPaused( thisSample->m_channel, FALSE ) )
{
char error[ MAX_PATH ];
sprintf( error, "%s\n", FMOD_ErrorString( FSOUND_GetError() ) );
ShowError( error, __FILE__, __LINE__ );
}
}
int CMusicMng::LoadSamples ()
{
if( !Enabled() ) return true;
if( !m_bEnable ) return false;
if( !m_inited ) return true;
int i;
for( i = 0; i < m_numSamples; i ++ )
{
if( !m_inited3D ) m_samples[i].m_is3D = false;
if( RegisterSample( m_samples[i].m_name, (RHANDLE)&m_samples[i], &m_samples[i], RES_INIT_NOTCREATE ) )
{
m_samples [i].m_idxSound = m_numSounds++;
m_samples [i].m_isLoaded = true;
}
else
{
m_samples [i].m_isLoaded = false;
}
m_samples [i].m_isPlaying = false;
}
return true;
}
void CMusicMng::LockMusicMng()
{
if( m_lockedState ) return;
m_lockedState = true;
}
void CMusicMng::EnableMusicMng()
{
if( m_lockedState ) return;
m_enabledState = true;
}
void CMusicMng::DisableMusicMng()
{
if ( m_lockedState ) return;
m_enabledState = false;
}
#endif | C++ |
#include "../global_def.h"
inline void SetSample( char *name, int maxBuffers, int idxSample, int is3D )
{
CSoundSample *sample;
sample = &g_musicMng ->m_samples [idxSample];
strcpy( sample->m_name, name );
sample->m_is3D = is3D;
sample->m_idxSound = -1;
sample->m_sample = NULL;
g_musicMng->m_numSamples++;
}
void ConfigGameSamples()
{
int i, j, soundID = 0;
int is3D;
for( i = 0; i < g_soundMng->m_soundResource.numNoramlID; i ++ )
{
if( g_soundMng->m_soundResource.normalID[i].is3D ) is3D = true;
else is3D = false;
SetSample( g_soundMng->m_soundResource.normalID[i].filename, g_soundMng->m_soundResource.normalID[i].numDup,
soundID, is3D );
g_soundMng->m_soundResource.normalID[i].soundID = soundID;
soundID ++;
}
for( i = 0; i < g_soundMng->m_soundResource.numItemID; i ++ )
{
if( g_soundMng->m_soundResource.itemID[i].is3D ) is3D = true;
else is3D = false;
SetSample( g_soundMng->m_soundResource.itemID[i].filename, g_soundMng->m_soundResource.itemID[i].numDup,
soundID, is3D );
g_soundMng->m_soundResource.itemID[i].soundID = soundID;
soundID ++;
}
for( i = 0; i < MAX_ANIMCOUNT_TYPE; i ++ )
{
for( j = 0; j < g_soundMng->m_soundResource.numEventID[i]; j ++ )
{
if( g_soundMng->m_soundResource.eventID[i][j].is3D ) is3D = true;
else is3D = false;
SetSample( g_soundMng->m_soundResource.eventID[i][j].filename, g_soundMng->m_soundResource.eventID[i][j].numDup,
soundID, is3D );
g_soundMng->m_soundResource.eventID[i][j].soundID = soundID;
soundID ++;
}
}
}
void ConfigMDLSamples()
{
int i;
for( i = 0; i < g_soundMng->m_nummdlSoundID; i ++ )
{
SetSample ( g_soundMng->m_mdlSoundID[i].soundname, 10, g_soundMng->m_mdlSoundID[i].idx , true );
}
}
int GetGameSampleID( char *path )
{
return -1;
}
| C++ |
#ifndef _MUSIC_MANAGER_FMOD_H_LKDAS95DDSL20GS
#define _MUSIC_MANAGER_FMOD_H_LKDAS95DDSL20GS
#define MAX_SIZE_SOUND 600
typedef enum
{
GTH_SOUND_PLAY_ONCE = 0,
GTH_SOUND_PLAY_LOOP,
GTH_SOUND_PLAY_TIME
} GTH_SOUND_PLAY_TYPE;
class CSoundSample : public BaseResource
{
public :
CSoundSample();
virtual ~CSoundSample();
char m_name[GTH_MAX_SIZE_FILENAME];
int m_idxSound;
int m_is3D;
int m_isPlaying;
int m_isLoaded;
int m_channel;
FSOUND_SAMPLE *m_sample;
int m_size;
void Clear()
{
m_sample = NULL;
}
bool Create( char *fname, int iSize );
bool Register( char *fname, int iSize )
{
m_size = iSize;
return true ;
}
virtual bool Recreate();
virtual void Dispose()
{
if( m_sample ) FSOUND_Sample_Free( m_sample );
m_sample = NULL;
}
size_t GetSize()
{
if( m_sample ) return m_size;
else return 0;
}
bool IsDisposed()
{
if( m_sample ) return false;
else return true;
}
};
class CMusicMng
{
public:
FSOUND_STREAM *m_BGMStream;
char m_bgFilename[GTH_MAX_SIZE_FILENAME];
int m_bgHandle;
int m_numSounds;
int m_numSamples;
int m_inited;
int m_inited3D;
int m_supporteax2;
int m_supporteax3;
CSoundSample m_samples [MAX_SIZE_SOUND];
bool m_bEffect;
bool m_bBgm;
bool m_bEnable;
int m_bgmVolume;
int m_effectVolume;
bool m_enabledState;
bool m_lockedState;
int m_bgVolumePercentage;
int m_effectVolumePercentage;
int m_bgmDefaultVolume;
int m_effectDefaultVolume;
CResManager m_resManager;
public:
CMusicMng ();
~CMusicMng ();
public:
int Initialize( HWND in_hwnd );
void CloseBGSample();
int PlayBGMusic( char *in_musicName );
void StopBGMusic();
int ChangeBGMusic( char *in_musicName );
void SetBGMusicVolume( int in_volume );
void SetVolume( int in_masterVolume );
void UpdateListener( vec3_t position, vec3_t velocity, vec3_t orientation );
void Stop();
int Stop( int in_index );
int LoadSamples();
void ReleaseAllSamples();
int IsPlaying( int idxSample );
void PlaySample( int idxSample, GTH_SOUND_PLAY_TYPE play );
void PlaySample3D( int idxSample, GTH_SOUND_PLAY_TYPE play, vec3_t pos );
void InitBGMusic() {};
void SetBgm( bool bBgm );
inline void SetEffect( bool bEffect ) { m_bEffect = bEffect; }
inline bool GetBgm() { return m_bBgm; }
inline bool GetEffect() { return m_bEffect; }
inline int GetBgmVolume() { return m_bgmVolume; }
inline int GetEffectVolume() { return m_effectVolume; }
inline void SetBgmVolumeDefault( int in_bgVolDefault ) { m_bgmVolume = in_bgVolDefault; }
inline void SetEffectVolumeDefault( int in_effectVolDefault ) { m_effectVolume = in_effectVolDefault; }
inline void SetBgmVolumePercentage( int in_bgVolPercentage ) { m_bgVolumePercentage = in_bgVolPercentage; }
inline void SetEffectVolumePercentage( int in_effectVolPercentage ) { m_effectVolumePercentage = in_effectVolPercentage; }
inline int GetBgmVolumePercentage() { return m_bgVolumePercentage; }
inline int GetEffectVolumePercentage() { return m_effectVolumePercentage; }
inline void RefreshBgmVolume() { SetBGMusicVolume( int( m_bgmVolume * m_bgVolumePercentage * 0.01f ) ); }
inline void RefreshEffectVolume() { SetVolume( int( m_effectVolume * m_effectVolumePercentage * 0.01f ) ); }
void EnableMusicMng();
void DisableMusicMng();
void LockMusicMng();
bool Enabled() { return m_enabledState; }
inline bool RegisterSample( char* fname, RHANDLE rhID, BaseResource *pRes, DWORD initialType )
{
FILE *fp;
DWORD size;
fp = fopen( fname, "rb" );
if( !fp )
{
return false;
}
fseek( fp, 0, SEEK_END );
size = ftell( fp );
fclose( fp );
if( initialType & RES_INIT_NOTCREATE )
{
if( !m_resManager.RegisterResource( rhID, pRes ) ) return false;
if( !pRes->Register( fname, size ) ) return false;
}
else
{
if( !m_resManager.ReserveMemory( size ) ) return false;
if( !pRes->Create( fname, size ) ) return false;
if( !m_resManager.InsertResource( rhID, pRes ) ) return false;
}
return true;
}
inline CSoundSample* GetSample( int idx )
{
CSoundSample *sample = &m_samples[idx];
bool bIsDisposed = sample->IsDisposed();
if( m_resManager.GetResource( (RHANDLE)sample ) == NULL )
{
return NULL;
}
if( bIsDisposed )
{
}
return sample;
}
};
#endif | C++ |
#include "../global_def.h"
CSoundMng::CSoundMng()
{
}
CSoundMng::~CSoundMng()
{
}
void CSoundMng::Initialize()
{
int i, j;
memset( &m_soundResource, 0, sizeof( gthSoundResource_t ) );
for( i = 0; i < 128; i ++ )
{
m_soundResource.normalID[i].idx = -1;
m_soundResource.itemID[i].idx = -1;
for( j = 0; j < MAX_ANIMCOUNT_TYPE; j ++ )
{
m_soundResource.eventID[j][i].idx = -1;
}
}
m_nummdlSoundID = 0;
for( i = 0; i < MAX_COUNT_GTH_MDL_SOUND_ID; i ++ )
{
m_mdlSoundID[i].idx = -1;
memset( m_mdlSoundID[i].mdlname, 0, sizeof( m_mdlSoundID [i].mdlname ) );
memset( m_mdlSoundID[i].soundname, 0, sizeof( m_mdlSoundID [i].soundname ) );
}
for( i = 0; i < MAX_COUNT_GTH_MONSTER_SOUND; i ++ )
{
m_monSound[i].idx = -1;
for( j = 0; j < MAX_ANIMCOUNT_TYPE; j ++ )
{
m_monSound[i].soundID[j] = -1;
m_monSound[i].frequency[j] = 1;
m_monSound[i].playTime[j] = 0.0f;
m_monSound[i].playCount[j] = 1;
}
m_monSound[i].playCount[ANIM_ITEM_RUN] = 2;
m_monSound[i].playCount[ANIM_ITEM_WALK] = 2;
}
for( i = 0; i < MAX_COUNT_GTH_PC_SOUND; i ++ )
{
m_pcSound[i].idx = -1;
for( j = 0; j < MAX_ANIMCOUNT_TYPE; j ++ )
{
m_pcSound[i].soundID[j] = -1;
m_pcSound[i].frequency[j] = 1;
m_pcSound[i].playTime[j] = 0.0f;
m_pcSound[i].playCount[j] = 1;
}
m_pcSound[i].playCount[ANIM_ITEM_RUN] = 2;
m_pcSound[i].playCount[ANIM_ITEM_WALK] = 2;
}
for( i = 0; i < MAX_COUNT_GTH_ITEM_SOUND; i ++ )
{
m_itemSound[i].idx = -1;
m_itemSound[i].soundID = -1;
}
}
void CSoundMng::LoadMDLSoundConfig( char *in_filename )
{
if( !g_script.Load( in_filename ) ) return;
char *token;
g_script.BeginParse();
m_nummdlSoundID = 0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( !token[0] ) break;
m_mdlSoundID[m_nummdlSoundID].idx = m_maxIdx + m_nummdlSoundID;
strcpy ( m_mdlSoundID [m_nummdlSoundID].mdlname, token );
token = g_script .GetNextToken ( true );
strcpy ( m_mdlSoundID [m_nummdlSoundID].soundname, token );
++m_nummdlSoundID;
}
}
void CSoundMng::LoadSoundConfig( char* filename )
{
char* token;
char soundName[128];
int idx, is3D, dup, resType = 0, type, eventType, soundID;
float fraction, freq;
Initialize();
g_script.Load( filename );
g_script.BeginParse();
m_maxIdx = 0;
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == 0 ) break;
if( !stricmp( token, "RESOURCE" ) ) resType = 0;
if( !stricmp( token, "MATCHING" ) ) resType = 1;
else if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
if( !resType )
{
if( !stricmp( token, "NORMAL" ) ) type = 0;
else if( !stricmp( token, "ITEM" ) ) type = 1;
else if( !stricmp( token, "EVENT_IDLE" ) ) { type = 2; eventType = ANIM_ITEM_IDLE; }
else if( !stricmp( token, "EVENT_DAMAGE" ) ) { type = 2; eventType = ANIM_ITEM_DEFENSE; }
else if( !stricmp( token, "EVENT_DIE" ) ) { type = 2; eventType = ANIM_ITEM_DYING_0; }
else if( !stricmp( token, "EVENT_WALK" ) ) { type = 2; eventType = ANIM_ITEM_WALK; }
else if( !stricmp( token, "EVENT_RUN" ) ) { type = 2; eventType = ANIM_ITEM_RUN; }
else if( !stricmp( token, "EVENT_ATTACK" ) ) { type = 2; eventType = ANIM_ITEM_ATTACK_0; }
else if( !stricmp( token, "EVENT_SHOCK" ) ) { type = 2; eventType = ANIM_ITEM_ATTACKED_0; }
else if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
idx = atoi( token );
token = g_script.GetNextToken( true );
strcpy( soundName, token );
token = g_script.GetNextToken( true );
is3D = atoi( token );
token = g_script.GetNextToken( true );
dup = atoi( token );
if( type == 0 )
{
m_soundResource.normalID[idx].idx = idx;
strcpy( m_soundResource.normalID[idx].filename, soundName );
m_soundResource.normalID[idx].is3D = is3D;
m_soundResource.normalID[idx].numDup = dup;
m_soundResource.numNoramlID ++;
m_maxIdx ++;
}
else if( type == 1 )
{
m_soundResource.itemID[idx].idx = idx;
strcpy( m_soundResource.itemID[idx].filename, soundName );
m_soundResource.itemID[idx].is3D = is3D;
m_soundResource.itemID[idx].numDup = dup;
m_soundResource.numItemID ++;
m_maxIdx ++;
}
else if( type == 2 )
{
m_soundResource.eventID[eventType][idx].idx = idx;
strcpy( m_soundResource.eventID[eventType][idx].filename, soundName );
m_soundResource.eventID[eventType][idx].is3D = is3D;
m_soundResource.eventID[eventType][idx].numDup = dup;
m_soundResource.numEventID[eventType] ++;
m_maxIdx ++;
}
}
}
}
else
{
if( !stricmp( token, "ITEM" ) ) type = 0;
else if( !stricmp( token, "PC" ) ) type = 1;
else if( !stricmp( token, "MONSTER" ) ) type = 2;
else if( token[0] == '{' )
{
while( 1 )
{
token = g_script.GetNextToken( true );
if( token[0] == '}' ) break;
else if( type == 0 )
{
idx = atoi( token );
token = g_script.GetNextToken( true );
soundID = atoi( token );
token = g_script.GetNextToken( true );
fraction = atof( token );
m_itemSound[idx].idx = idx;
m_itemSound[idx].soundID = soundID;
m_itemSound[idx].playTime = fraction;
}
else if( type == 1 )
{
if( !stricmp( token, "IDX" ) ) eventType = -1;
else if( !stricmp( token, "IDLE" ) ) eventType = ANIM_ITEM_IDLE;
else if( !stricmp( token, "WALK" ) ) eventType = ANIM_ITEM_WALK;
else if( !stricmp( token, "RUN" ) ) eventType = ANIM_ITEM_RUN;
else if( !stricmp( token, "DAMAGE" ) ) eventType = ANIM_ITEM_DEFENSE;
else if( !stricmp( token, "ATTACK" ) ) eventType = ANIM_ITEM_ATTACK_0;
else if( !stricmp( token, "SHOCK" ) ) eventType = ANIM_ITEM_ATTACKED_0;
else if( !stricmp( token, "DIE" ) ) eventType = ANIM_ITEM_DYING_0;
else if( eventType == -1 )
{
idx = atoi( token );
}
else
{
soundID = atoi( token );
token = g_script.GetNextToken( true );
fraction = atof( token );
token = g_script.GetNextToken( true );
freq = atoi( token );
m_pcSound[idx].idx = idx;
m_pcSound[idx].soundID[eventType] = soundID;
m_pcSound[idx].playTime[eventType] = fraction;
m_pcSound[idx].frequency[eventType] = freq;
}
}
else if( type == 2 )
{
if( !stricmp( token, "IDX" ) ) eventType = -1;
else if( !stricmp( token, "IDLE" ) ) eventType = ANIM_ITEM_IDLE;
else if( !stricmp( token, "WALK" ) ) eventType = ANIM_ITEM_WALK;
else if( !stricmp( token, "RUN" ) ) eventType = ANIM_ITEM_RUN;
else if( !stricmp( token, "DAMAGE" ) ) eventType = ANIM_ITEM_DEFENSE;
else if( !stricmp( token, "ATTACK" ) ) eventType = ANIM_ITEM_ATTACK_0;
else if( !stricmp( token, "SHOCK" ) ) eventType = ANIM_ITEM_ATTACKED_0;
else if( !stricmp( token, "DIE" ) ) eventType = ANIM_ITEM_DYING_0;
else if( eventType == -1 )
{
idx = atoi( token );
}
else
{
soundID = atoi( token );
token = g_script.GetNextToken( true );
fraction = atof( token );
token = g_script.GetNextToken( true );
freq = atoi( token );
m_monSound[idx].idx = idx;
m_monSound[idx].soundID[eventType] = soundID;
m_monSound[idx].playTime[eventType] = fraction;
m_monSound[idx].frequency[eventType] = freq;
}
}
}
}
}
}
}
}
}
void CSoundMng::PlayCharSound( Fx_CHARACTER_t* character )
{
int itemIdx, mainClass, soundID, tableIdx;
float fraction;
if ( character->isTransform )
{
PlayMonsterSound(character);
return ;
}
fraction = g_charManager->GetAnimFraction( character );
tableIdx = character->tableIdx;
{
switch( character->ani_curSetID )
{
case ANIM_ITEM_ATTACK_0 : case ANIM_ITEM_ATTACK_1 : case ANIM_ITEM_ATTACK_2 :
case ANIM_ITEM_ATTACK_3 : case ANIM_ITEM_ATTACK_4 :
{
return;
if ( character->equipNumber > 0 )
{
itemIdx = character->equipment[0];
mainClass = g_itemTable[itemIdx].classIdx;
if ( g_itemClassTable[mainClass].attackAtt )
{
if( m_itemSound[itemIdx].soundID < 0 ) return;
{
g_musicMng->PlaySample3D( GetItemSoundID( m_itemSound[itemIdx].soundID ), GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
}
}
}
break;
case ANIM_ITEM_RUN :
{
if( m_pcSound[tableIdx].soundID[ANIM_ITEM_RUN] < 0 ) return;
if( m_pcSound[tableIdx].playTime[ANIM_ITEM_RUN] > fraction ) return;
if( fraction < 0.8 && m_pcSound[tableIdx].playCount[ANIM_ITEM_RUN] == 1 ) return;
m_pcSound[tableIdx].playCount[ANIM_ITEM_RUN] --;
soundID = GetEventSoundID( ANIM_ITEM_RUN, m_pcSound[tableIdx].soundID[ANIM_ITEM_RUN] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
if( m_pcSound[tableIdx].playCount[ANIM_ITEM_RUN] <= 0 ) character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_WALK :
{
if( m_pcSound[tableIdx].soundID[ANIM_ITEM_WALK] < 0 ) return;
if( m_pcSound[tableIdx].playTime[ANIM_ITEM_WALK] > fraction ) return;
if( fraction < 0.8 && m_pcSound[tableIdx].playCount[ANIM_ITEM_WALK] == 1 ) return;
m_pcSound[tableIdx].playCount[ANIM_ITEM_WALK] --;
soundID = GetEventSoundID( ANIM_ITEM_WALK, m_pcSound[tableIdx].soundID[ANIM_ITEM_WALK] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
if( m_pcSound[tableIdx].playCount[ANIM_ITEM_WALK] <= 0 ) character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_DYING_0 :
{
if( m_pcSound[tableIdx].soundID[ANIM_ITEM_DYING_0] < 0 ) return;
if( m_pcSound[tableIdx].playTime[ANIM_ITEM_DYING_0] > fraction ) return;
soundID = GetEventSoundID( ANIM_ITEM_DYING_0, m_pcSound[tableIdx].soundID[ANIM_ITEM_DYING_0] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_ATTACKED_0 :
{
if( m_pcSound[tableIdx].soundID[ANIM_ITEM_ATTACKED_0] < 0 ) return;
if( m_pcSound[tableIdx].playTime[ANIM_ITEM_ATTACKED_0] > fraction ) return;
soundID = GetEventSoundID( ANIM_ITEM_ATTACKED_0, m_pcSound[tableIdx].soundID[ANIM_ITEM_ATTACKED_0] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
}
}
}
void CSoundMng::PlayMonsterSound( Fx_CHARACTER_t* character )
{
int soundID, tableIdx;
float soundTime;
float fraction;
fraction = g_charManager->GetAnimFraction( character );
if ( character->isTransform)
tableIdx = character->transformEntityIdx;
else
tableIdx = character->tableIdx;
switch( character->ani_curSetID )
{
case ANIM_ITEM_ATTACK_0 : case ANIM_ITEM_ATTACK_1 : case ANIM_ITEM_ATTACK_2 :
case ANIM_ITEM_ATTACK_3 : case ANIM_ITEM_ATTACK_4 :
{
if( m_monSound[tableIdx].playTime[ANIM_ITEM_ATTACK_0] > fraction ) return;
if( m_monSound[tableIdx].soundID[ANIM_ITEM_ATTACK_0] < 0 ) return;
soundID = GetEventSoundID( ANIM_ITEM_ATTACK_0, m_monSound[tableIdx].soundID[ANIM_ITEM_ATTACK_0] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_IDLE :
{
if( m_monSound[tableIdx].soundID[ANIM_ITEM_IDLE] < 0 ) return;
soundTime = g_timer.GetAppMilliTime() - character->soundTime;
if( soundTime > 60000 / m_monSound[tableIdx].frequency[ANIM_ITEM_IDLE] )
{
character->soundTime = g_timer.GetAppMilliTime();
if( rand() % 2 == 0 ) return;
soundID = GetEventSoundID( ANIM_ITEM_IDLE, m_monSound[tableIdx].soundID[ANIM_ITEM_IDLE] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
}
break;
case ANIM_ITEM_RUN :
{
if( m_monSound[tableIdx].soundID[ANIM_ITEM_RUN] < 0 ) return;
if( m_monSound[tableIdx].playTime[ANIM_ITEM_RUN] > fraction ) return;
if( fraction < 0.8 && m_monSound[tableIdx].playCount[ANIM_ITEM_RUN] == 1 ) return;
m_monSound[tableIdx].playCount[ANIM_ITEM_RUN] --;
soundID = GetEventSoundID( ANIM_ITEM_RUN, m_monSound[tableIdx].soundID[ANIM_ITEM_RUN] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
if( m_monSound[tableIdx].playCount[ANIM_ITEM_RUN] <= 0 ) character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_WALK :
{
}
break;
case ANIM_ITEM_DYING_0 :
{
if( m_monSound[tableIdx].soundID[ANIM_ITEM_DYING_0] < 0 ) return;
if( m_monSound[tableIdx].playTime[ANIM_ITEM_DYING_0] > fraction ) return;
soundID = GetEventSoundID( ANIM_ITEM_DYING_0, m_monSound[tableIdx].soundID[ANIM_ITEM_DYING_0] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
case ANIM_ITEM_ATTACKED_0 :
{
if( m_monSound[tableIdx].soundID[ANIM_ITEM_ATTACKED_0] < 0 ) return;
if( m_monSound[tableIdx].playTime[ANIM_ITEM_ATTACKED_0] > fraction ) return;
soundID = GetEventSoundID( ANIM_ITEM_ATTACKED_0, m_monSound[tableIdx].soundID[ANIM_ITEM_ATTACKED_0] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
character->stat_sound = CHAR_SOUND_DISABLE;
}
break;
}
}
void CSoundMng::Play( Fx_CHARACTER_t* character )
{
if( character->stat_sound == CHAR_SOUND_DISABLE ) return;
if( character->entityType == ENTITY_PC ) PlayCharSound( character );
else if( character->entityType == ENTITY_MONSTER || character->entityType == ENTITY_NPC ) PlayMonsterSound( character );
}
void CSoundMng::PlayDamageSound( Fx_CHARACTER_t* character )
{
int tableIdx, soundID;
if( character->entityType == ENTITY_MONSTER || character->entityType == ENTITY_PC )
{
tableIdx = character->tableIdx;
if( m_monSound[tableIdx].soundID[ANIM_ITEM_DEFENSE] < 0 ) return;
soundID = GetEventSoundID( ANIM_ITEM_DEFENSE, m_monSound[tableIdx].soundID[ANIM_ITEM_DEFENSE] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
}
else
{
tableIdx = character->tableIdx;
if( m_pcSound[tableIdx].soundID[ANIM_ITEM_DEFENSE] < 0 ) return;
soundID = GetEventSoundID( ANIM_ITEM_DEFENSE, m_pcSound[tableIdx].soundID[ANIM_ITEM_DEFENSE] );
g_musicMng->PlaySample3D( soundID, GTH_SOUND_PLAY_ONCE , character->position );
}
}
int CSoundMng::GetNormalSoundID( int idx )
{
return( m_soundResource.normalID[idx].soundID );
}
int CSoundMng::GetItemSoundID( int idx )
{
return( m_soundResource.itemID[idx].soundID );
}
int CSoundMng::GetEventSoundID( int event, int idx )
{
return( m_soundResource.eventID[event][idx].soundID );
} | C++ |
#include "../Global_def.h"
extern char *g_lTableToken[];
CGameConfigFlag gGameConfigFlag;
void CGameConfigFlag::SetFlag()
{
m_nFlag=0;
if(m_bPrecocity_Time) m_nFlag +=1 << 1;
if(m_bDie_Reduce_panality) m_nFlag +=1 << 2;
if(m_bMap_Attr_Ratio) m_nFlag +=1 << 3;
if(m_bItem_Upgrade_Limit) m_nFlag +=1 << 4;
if(m_bItem_Craft_Limit) m_nFlag +=1 << 5;
if(m_bWorld_Chat_Limit) m_nFlag +=1 << 6;
return ;
}
void CGameConfigFlag::SetFlag(int flag)
{
m_nFlag = flag;
int f=0;
if(flag & (1 << 1)) m_bPrecocity_Time=TRUE;
if(flag & (1 << 2)) m_bDie_Reduce_panality=TRUE;
if(flag & (1 << 3)) m_bMap_Attr_Ratio=TRUE;
if(flag & (1 << 4)) m_bItem_Upgrade_Limit=TRUE;
if(flag & (1 << 5)) m_bItem_Craft_Limit=TRUE;
if(flag & (1 << 6)) m_bWorld_Chat_Limit=TRUE;
}
int CGameConfigFlag::LoadFlagFile()
{
FILE *fp=NULL;
int size=0;
byte *buffer=NULL;
char *token=NULL;
char filename[128];
sprintf( filename, "flag%s.cfg", g_lTableToken[g_cgv.languageType] );
fp = fopen(filename, "rb" );
if( !fp )
{
MessageBox(NULL, "does not exist 'flag.cfg' file", "Error", MB_ICONHAND|MB_OK);
return false;
}
fseek(fp,0,SEEK_END);
size = ftell(fp);
buffer = new byte[size];
fseek(fp,0,SEEK_SET);
fread(buffer,size,1,fp);
fclose(fp);
curpos = (char *)buffer;
endpos = curpos + size;
while ((token = NextToken()) != NULL)
{
if( !stricmp( token, "CHARACTER_STORAGE" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bCharacter_Storage = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bCharacter_Storage = FALSE;
}
else if( !stricmp( token, "PRECOCITY_TIME" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bPrecocity_Time = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bPrecocity_Time = FALSE;
}
else if( !stricmp( token, "DIE_REDUCE_PANALTY" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bDie_Reduce_panality = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bDie_Reduce_panality = FALSE;
}
else if( !stricmp( token, "MAP_ATTR_RATIO" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bMap_Attr_Ratio = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bMap_Attr_Ratio = FALSE;
}
else if( !stricmp( token, "ITEM_UPGRADE_LIMIT" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bItem_Craft_Limit = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bItem_Craft_Limit = FALSE;
}
else if( !stricmp( token, "WORLD_CHAT_LIMIT" ) )
{
token = NextArg();
if(token == "TRUE") gGameConfigFlag.m_bWorld_Chat_Limit = TRUE;
else if (token == "FALSE") gGameConfigFlag.m_bWorld_Chat_Limit = FALSE;
}
}
fclose(fp);
delete [] buffer;
return true;
} | C++ |
#if !defined(AFX_HELPERSYSTEM_H__33CDCCE3_CA51_4521_A551_CE49C3B0DF59__INCLUDED_)
#define AFX_HELPERSYSTEM_H__33CDCCE3_CA51_4521_A551_CE49C3B0DF59__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
enum
{
MAX_TAKER_LIST = 10,
};
struct HelperEntry
{
int level ;
int job ;
int worldIdx ;
char name[NAMESTRING+1];
bool bDeleteMe;
};
struct PointInfo
{
int iMyPoint;
int iHelpPoint;
int iTotalHelpPoint;
int iWebPoint;
};
class CHelperSystem
{
public:
enum enumHelperPacket
{
CS_INVITE_Req_fromHELPER = 0,
SC_INVITE_Req_toTAKER = 1,
CS_INVITE_Res_fromTAKER = 2,
SC_INVITE_Res_toHELPER = 3,
SC_INVITE_Res_toTAKER = 4,
CS_REMOVE_Req_fromPlayer = 5,
SC_REMOVE_Res_toPlayer = 6,
SC_REMOVE_NOTIFY_toPlayer = 7,
SC_SEND_MEMBERLIST_toAllPlayer = 8,
SC_SEND_ADD_toPlayer = 9,
SC_LIST_Res_toServer = 10,
SC_LISTINFO_toAllPlayer = 11,
CS_GIVEPOINT_Req_toHelper = 12,
SC_UPDATE_POINTINFO_SEND_toPlayer = 13,
CS_SPAWN_Req_fromHelper = 14,
CS_SPAWN_Res_fromTaker = 15,
SC_SPAWN_Req_toTaker = 16,
SC_SPAWN_Req_toServer = 17,
SC_SPAWN_Res_toTaker = 18,
SC_SPAWN_Res_toServer = 19,
CS_CONFIRM_MYPOINT_Req_fromPlayer = 20,
SC_CONFIRM_MYPOINT_Res_toPlayer = 21,
CS_CONFIRM_HELPPOINT_Req_fromPlayer = 22,
SC_CONFIRM_HELPPOINT_Res_toPlayer = 23,
CS_CONFIRM_WEPPOINT_Req_fromPlayer = 24,
SC_CONFIRM_WEPPOINT_Res_toPlayer = 25,
SC_STACK_OPEN_Req_toPlayer = 26,
CS_MemBerList_Req_fromPlayer = 27,
SC_SENDMYPOINT_toAllPlayer = 28,
SC_SENDHELPPOINT_toHelper = 29,
};
int m_iGivePoint;
struct HelperEntry m_HelperEntry[MAX_TAKER_LIST];
struct PointInfo m_MyPointInfo;
CHelperSystem();
virtual ~CHelperSystem();
void GTH_ProcessMessage_RecvHelpSystem(void);
void GTH_ProcessMessage_HelpSystem_NeedToHelper(void);
void GTH_ProcessMessage_HelpSystem_DoYouWant(void);
void GTH_ProcessMessage_HelpSystem_RequstComplete(void);
void GTH_ProcessMessage_HelpSystem_RemovePlayer(void);
void GTH_ProcessMessage_HelpSystem_NotifytoRemovePlayer(void);
void GTH_ProcessMessage_HelpSystem_AddToPlayer(void);
void GTH_ProcessMessage_HelpSystem_UpDateListAll(void);
void GTH_ProcessMessage_HelpSystem_UpDateList(void);
void GTH_ProcessMessage_HelpSystem_UpDatePointInfo(void);
void GTH_ProcessMessage_HelpSystem_SpawnTaker(void);
void GTH_ProcessMessage_HelpSystem_Portal(void);
void GTH_ProcessMessage_HelpSystem_DisplayMyPoint(void);
void GTH_ProcessMessage_HelpSystem_DisplayHelpPoint(void);
void GTH_ProcessMessage_HelpSystem_DisplayWebPoint(void);
void GTH_ProcessMessage_HelpSystem_StackOpen(void);
void GTH_ProcessMessage_HelpSystem_GivePointResultToTaker(void);
void GTH_ProcessMessage_HelpSystem_GivePointResultToHelper(void);
void GTH_SendMessage_HelpSystem_DoYouWant(void);
void GTH_SendMessage_HelpSystem_AnswerYesOrNo(int Answer);
void GTH_SendMessage_HelpSystem_RemovePlayer(char *DeleteHelperName);
void GTH_SendMessage_HelpSystem_GivePointToHelper(int GivePoint, char *HelperName);
void GTH_SendMessage_HelpSystem_SpawnTaker(char *SpawnHelperName);
void GTH_SendMessage_HelpSystem_SpawnMeAnswer(int YesOrNo);
void GTH_SendMessage_HelpSystem_DisplayMyPoint(void);
void GTH_SendMessage_HelpSystem_DisplayHelpPoint(void);
void GTH_SendMessage_HelpSystem_DisplayWebPoint(void);
void GTH_SendMessage_HelpSystem_GiveMeListAll(void);
BOOL IsChild(char* Name);
};
#endif
| C++ |
#if !defined(AFX_POSTFUNC_H__B30E5206_64CC_41DA_9772_80C94378B55E__INCLUDED_)
#define AFX_POSTFUNC_H__B30E5206_64CC_41DA_9772_80C94378B55E__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "tagGCPacket.h"
class CPostFunc
{
public:
void GTH_SendMessage_PostSystem_Send();
int GTH_SendMessage_PostSystem_ReceiveItems();
void GTH_SendMessage_PostSystem_State();
void GTH_SendMessage_PostSystem_View();
void GTH_SendMessage_PostSystem_DeletePost();
void GTH_SendMessage_PostSystem_ExitWindow();
void GTH_SendMessage_PostSystem_WriteOpen(void);
int GTH_SendMessage_MailBox_Open(int PostType, int PostIdx);
int GTH_SendMessage_MailBox_Item( int idx, int pos );
int GTH_SendMessage_MailBox_Exit();
bool GTH_SendMessage_MailBox_UndoInvenItem(void);
public:
void GTH_ProcessMessage_RecvPostSystem();
void GTH_ProcessMessage_PostSystem_OpenWindow();
void GTH_ProcessMessage_PostSystem_WriteOpen(void);
void GTH_ProcessMessage_PostSystem_Send();
void GTH_ProcessMessage_PostSystem_ReceiveItems();
void GTH_ProcessMessage_PostSystem_State();
void GTH_ProcessMessage_PostSystem_View();
void GTH_ProcessMessage_PostSystem_Arrive();
void GTH_ProcessMessage_PostSystem_ExitWindow();
void GTH_ProcessMessage_PostSystem_DeletePost();
void GTH_ProcessMessage_PostSystem_SendComplete(void);
void GTH_ProcessMessage_MailBox_UndoInvenItem();
void GTH_ProcessMessage_MailBox_Open();
void GTH_ProcessMessage_RecvMailBox();
int GTH_ProcessMessage_MailBox_Item();
void GTH_ProcessMessage_MailBox_Exit();
protected:
inline void GTH_ProcessMessage_PostSystem_ReceiveItems_Success(void);
public:
CPostFunc();
virtual ~CPostFunc();
int GetItemCount();
bool Safe_ItemBox(int index);
};
#endif
| C++ |
#include "../global_def.h"
CExpRateMng::CExpRateMng()
{
}
CExpRateMng::~CExpRateMng()
{
}
void CExpRateMng::ProcessMessage()
{
short Protocal = static_cast<enum enumProtocal>(MSG_ReadShort());
switch(Protocal)
{
case GSC_REPLY_EVENT_STATUS:
Processage_ReplyEventStatus();
break;
}
}
void CExpRateMng::SendMessage_SetEvent(enum enumEventType eventTYpe, float fvalue )
{
if ( fvalue <= 0.0f)
return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT );
MSG_WriteShort(&netMessage, CC_BROAD_CASE_SET_EVENT );
MSG_WriteLong(&netMessage, eventTYpe);
MSG_WriteFloat(&netMessage, fvalue);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpRateMng::SendMessage_SetEventActive(BOOL active)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT );
MSG_WriteShort(&netMessage, CC_SET_ACTIVE_SYSTEM );
MSG_WriteLong(&netMessage, active);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpRateMng::SendMessage_RequestEventStatus()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, EXP_EVENT );
MSG_WriteShort(&netMessage, CC_REQUEST_EVENT_STATUS );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CExpRateMng::Processage_ReplyEventStatus()
{
float Expvalue = MSG_ReadFloat();
float Itemdropvalue = MSG_ReadFloat();
float NakDropvalue = MSG_ReadFloat();
float Gencapvalue = MSG_ReadFloat();
char msg[256];
_snprintf(msg, 256, "[EXP]=%.1f, [ITEMDROP]=%.1f, [NAK]=%.1f, [GenCap]=%.1f",
Expvalue, Itemdropvalue, NakDropvalue, Gencapvalue);
msg[255]= NULL;
g_ifMng->AddSysMessage( msg ,GTHCOLOR_TRADEMESSAGE);
} | C++ |
#include "../global_def.h"
float g_optValue[NUM_OPTION_VALUE];
itemTable_t g_optItem;
itemTable_t g_oriItem;
void OPTION_InitGlobal()
{
memset( g_optValue, 0, sizeof( g_optValue ) );
}
int OPTION_GetItemType_MatchingAvailableOn( DWORD availableOn )
{
if( availableOn & OPTION_AVAILABLE_ON_WEAPONS ) return OPTION_ITEMTYPE_WEAPONS;
if( availableOn & OPTION_AVAILABLE_ON_DAGGER ) return OPTION_ITEMTYPE_DAGGER;
if( availableOn & OPTION_AVAILABLE_ON_1HSWORD ) return OPTION_ITEMTYPE_1HSWORD;
if( availableOn & OPTION_AVAILABLE_ON_2HSWORD ) return OPTION_ITEMTYPE_2HSWORD;
if( availableOn & OPTION_AVAILABLE_ON_BOW ) return OPTION_ITEMTYPE_BOW;
if( availableOn & OPTION_AVAILABLE_ON_STAFF ) return OPTION_ITEMTYPE_STAFF;
if( availableOn & OPTION_AVAILABLE_ON_SPIRITOR ) return OPTION_ITEMTYPE_SPIRITOR;
if( availableOn & OPTION_AVAILABLE_ON_CLAW ) return OPTION_ITEMTYPE_CLAW;
if( availableOn & OPTION_AVAILABLE_ON_ARMORS ) return OPTION_ITEMTYPE_ARMORS;
if( availableOn & OPTION_AVAILABLE_ON_UPPER ) return OPTION_ITEMTYPE_UPPER;
if( availableOn & OPTION_AVAILABLE_ON_LOWER ) return OPTION_ITEMTYPE_LOWER;
if( availableOn & OPTION_AVAILABLE_ON_AIRPROTECTOR ) return OPTION_ITEMTYPE_AIRPROTECTOR;
if( availableOn & OPTION_AVAILABLE_ON_BODYPROTECTOR ) return OPTION_ITEMTYPE_BODYPROTECTOR;
if( availableOn & OPTION_AVAILABLE_ON_GLOVES ) return OPTION_ITEMTYPE_GLOVES;
if( availableOn & OPTION_AVAILABLE_ON_BOOTS ) return OPTION_ITEMTYPE_BOOTS;
if( availableOn & OPTION_AVAILABLE_ON_RING ) return OPTION_ITEMTYPE_RING;
if( availableOn & OPTION_AVAILABLE_ON_NECKLACE ) return OPTION_ITEMTYPE_NECKLACE;
if( availableOn & OPTION_AVAILABLE_ON_BRACELET ) return OPTION_ITEMTYPE_BRACELET;
if( availableOn & OPTION_AVAILABLE_ON_EARRING ) return OPTION_ITEMTYPE_EARRING;
if( availableOn & OPTION_AVAILABLE_ON_EPACK ) return OPTION_ITEMTYPE_EPACK;
return -1;
}
DWORD OPTION_GetItemAvailalbeOn( int itemTableIdx )
{
int itemClassTableIdx = g_itemTable[itemTableIdx].classIdx;
DWORD availableOn = 0;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_WEAPON )
{
availableOn |= OPTION_AVAILABLE_ON_WEAPONS;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_DANGGER ) availableOn |= OPTION_AVAILABLE_ON_DAGGER;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_ONEHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_1HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_TWOHAND_SWORD ) availableOn |= OPTION_AVAILABLE_ON_2HSWORD;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_MAGIC_BOW ) availableOn |= OPTION_AVAILABLE_ON_BOW;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_STAFF ) availableOn |= OPTION_AVAILABLE_ON_STAFF;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_SPIRITOR ) availableOn |= OPTION_AVAILABLE_ON_SPIRITOR;
if( g_itemClassTable[itemClassTableIdx].weaponType == WEAPON_TYPE_CLAW ) availableOn |= OPTION_AVAILABLE_ON_CLAW;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_UPPER )
{
availableOn |= OPTION_AVAILABLE_ON_UPPER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_LOWER )
{
availableOn |= OPTION_AVAILABLE_ON_LOWER;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_AIR_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_AIRPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BODY_PROTECTOR )
{
availableOn |= OPTION_AVAILABLE_ON_BODYPROTECTOR;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_GLOVES )
{
availableOn |= OPTION_AVAILABLE_ON_GLOVES;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BOOTS )
{
availableOn |= OPTION_AVAILABLE_ON_BOOTS;
availableOn |= OPTION_AVAILABLE_ON_ARMORS;
}
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EPACK ) availableOn |= OPTION_AVAILABLE_ON_EPACK;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_RING ) availableOn |= OPTION_AVAILABLE_ON_RING;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_NECKLACE ) availableOn |= OPTION_AVAILABLE_ON_NECKLACE;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_BRACELET ) availableOn |= OPTION_AVAILABLE_ON_BRACELET;
if( g_itemTable[itemTableIdx].wearPosition == ITEM_WEAR_POS_EARRING ) availableOn |= OPTION_AVAILABLE_ON_EARRING;
return( availableOn );
}
int OPTION_GetOptionStoneGrade( item_t *item )
{
if( item->reqLevel >= 0 && item->reqLevel <= 29 ) return 0;
else if( item->reqLevel >= 30 && item->reqLevel <= 49 ) return 1;
else if( item->reqLevel >= 50 && item->reqLevel <= 69 ) return 2;
else if( item->reqLevel >= 70 ) return 3;
return 0;
}
float OPTION_GetOptionValue( item_t *item, int optionTableIdx, int optionGrade )
{
int optionStoneGrade = OPTION_GetOptionStoneGrade( item );
DWORD itemAvailableOn;
DWORD optAvailableOn;
int itemType;
if( optionGrade <= 0 ) return( 0 );
itemAvailableOn = OPTION_GetItemAvailalbeOn( item->itemTableIdx );
optAvailableOn = g_optionTable[optionTableIdx].optValue[optionStoneGrade].availableOn;
itemType = OPTION_GetItemType_MatchingAvailableOn( itemAvailableOn & optAvailableOn );
if( itemType < 0 ) return( 0 );
if( g_optionTable[optionTableIdx].optValue[optionStoneGrade].availableOn == 0 ) return( 0 );
return( g_optionTable[optionTableIdx].optValue[optionStoneGrade].value_item[itemType].value[optionGrade - 1] );
}
void OPTION_ApplyStatusOption( item_t *item, int status[] )
{
int i, statusIdx, optIdx, optGrade;
float optValue;
for( i = 0; i < item->optionNumber; i ++ )
{
statusIdx = -1;
optIdx = item->optionIdx[i];
optGrade = item->optionValue[i];
optValue = 0.0f;
if( optGrade > 10 ) optGrade = 10;
optValue = OPTION_GetOptionValue( item, optIdx, optGrade );
switch( optIdx )
{
case Opt_Bracelet_Add_Force :
statusIdx = 0;
break;
case Opt_Bracelet_Add_Soulpower :
statusIdx = 1;
break;
case Opt_Bracelet_Add_Agility :
statusIdx = 2;
break;
case Opt_Bracelet_Add_Vitality :
statusIdx = 3;
break;
}
if( statusIdx >= 0 ) status[statusIdx] += (int)optValue;
}
}
int OPTION_ApplyItemOption( item_t *item )
{
int i, optIdx, optGrade;
float optValue;
for( i = 0; i < item->optionNumber; i ++ )
{
optIdx = item->optionIdx[i];
optGrade = item->optionValue[i];
optValue = 0.0f;
if( optGrade > 10 ) optGrade = 10;
optValue = OPTION_GetOptionValue( item, optIdx, optGrade );
switch( optIdx )
{
case Opt_Add_PhyDamange :
optIdx = OV_W_PHYDMG;
break;
case Opt_Add_Min_PhyDamage :
optIdx = OV_W_MIN_PHYDMG;
break;
case Opt_Add_Max_PhyDamage :
optIdx = OV_W_MAX_PHYDMG;
break;
case Opt_Add_MagDamage :
optIdx = OV_W_MAGDMG;
break;
case Opt_Add_Min_MagDamage :
optIdx = OV_W_MIN_MAGDMG;
break;
case Opt_Add_Max_MagDamage :
optIdx = OV_W_MAX_MAGDMG;
break;
case Opt_Add_CriticalPro : case Opt_Ring_Add_CriticalPro :
optIdx = OV_CRITICAL_PRO;
break;
case Opt_Mul_CriticalDamage : case Opt_Ring_Mul_CriticalDamage :
optIdx = OV_CRITICAL_DMG_RATE;
break;
case Opt_Dec_CastingTime : case Opt_Bracelet_Dec_CastingTime :
optIdx = OV_DEC_CASTINGTIME_RATE;
optValue = -optValue;
break;
case Opt_Add_AttackSpeed :
optIdx = OV_W_ATKSPEED;
break;
case Opt_Add_HitPower : case Opt_Gloves_Add_HitPower :
optIdx = OV_W_HITPOWER;
break;
case Opt_Steal_RA : case Opt_Ring_Steal_RA :
optIdx = OV_RASTEAL;
break;
case Opt_Steal_SA : case Opt_Ring_Steal_SA :
optIdx = OV_SASTEAL;
break;
case Opt_Steal_RA_Point : case Opt_Ring_Steal_RA_Point :
optIdx = OV_RASTEAL_POINT;
break;
case Opt_Steal_SA_Point : case Opt_Ring_Steal_SA_Point :
optIdx = OV_SASTEAL_POINT;
break;
case Opt_Mul_Che_PhyDamage :
optIdx = OV_CHE_PHY_DMG_RATE;
break;
case Opt_Mul_Che_MagDamage :
optIdx = OV_CHE_MAG_DMG_RATE;
break;
case Opt_Mul_Mamul_PhyDamage :
optIdx = OV_MAMUL_PHY_DMG_RATE;
break;
case Opt_Mul_Mamul_MagDamage :
optIdx = OV_MAMUL_MAG_DMG_RATE;
break;
case Opt_Mul_Yogui_PhyDamage :
optIdx = OV_YO_PHY_DMG_RATE;
break;
case Opt_Mul_Yogui_MagDamage :
optIdx = OV_YO_MAG_DMG_RATE;
break;
case Opt_Mul_Yoguisun_PhyDamage :
optIdx = OV_YOSUN_PHY_DMG_RATE;
break;
case Opt_Mul_Yoguisun_MagDamage :
optIdx = OV_YOSUN_MAG_DMG_RATE;
break;
case Opt_Mul_Younghon_PhyDamage :
optIdx = OV_YOUNG_PHY_DMG_RATE;
break;
case Opt_Mul_Younghon_MagDamage :
optIdx = OV_YOUNG_MAG_DMG_RATE;
break;
case Opt_Armor_Add_DefensePower : case Opt_Bracelet_Add_DefensePower :
optIdx = OV_D_DEFPOWER;
break;
case Opt_Upper_Add_PositiveRes : case Opt_Necklace_Add_PositiveRes :
optIdx = OV_POSRES;
break;
case Opt_Upper_Add_NegativeRes : case Opt_Necklace_Add_NegativeRes :
optIdx = OV_NEGRES;
break;
case Opt_Boots_Add_AvoidPower :
optIdx = OV_AVOIDPOWER;
break;
case Opt_Boots_Add_Velocity :
optIdx = OV_VELOCITY;
break;
case Opt_Ring_Mul_PhyDamage :
optIdx = OV_PHYDMG_RATE;
break;
case Opt_Ring_Mul_MagDamage :
optIdx = OV_MAGDMG_RATE;
break;
case Opt_Necklace_Add_MaxRA :
optIdx = OV_MAX_RA;
break;
case Opt_Necklace_Add_MaxSA :
optIdx = OV_MAX_SA;
break;
case Opt_Necklace_Add_AvoidRate :
optIdx = OV_HIT_RATE;
break;
case Opt_Necklace_Add_HitRate :
optIdx = OV_AVOID_RATE;
break;
case Opt_Necklace_Dec_StunTime :
optIdx = OV_DEC_STUNDELAY_RATE;
break;
case Opt_Necklace_Dec_CursePro :
optIdx = OV_DEC_CURSESKILL_RATE;
break;
case Opt_Necklace_Trans_DamageToRA :
optIdx = OV_SA_STEAL_DAMAGED;
break;
case Opt_Necklace_Trans_DamageToSA :
optIdx = OV_RA_STEAL_DAMAGED;
break;
case Opt_Necklace_Mul_Recovery_RA_Normal :
optIdx = OV_AUTORECOVERY_RA_ATTACK;
break;
case Opt_Necklace_Mul_Recovery_SA_Normal :
optIdx = OV_AUTORECOVERY_SA_ATTACK;
break;
case Opt_Necklace_Mul_Recovery_RA_Rest :
optIdx = OV_AUTORECOVERY_RA_IDLE;
break;
case Opt_Necklace_Mul_Recovery_SA_Rest :
optIdx = OV_AUTORECOVERY_SA_IDLE;
break;
case Opt_Necklace_Mul_Recovery_EpackRA :
optIdx = OV_EPACK_RA_EFFICIENCY;
break;
case Opt_Necklace_Mul_Recovery_EpackSA :
optIdx = OV_EPACK_SA_EFFICIENCY;
break;
case Opt_Bracelet_Dec_CoolTime :
optIdx = OV_DEC_COOLTIME_RATE;
optValue = -optValue;
break;
case Opt_Bracelet_Steal_RAPoint_MonsterDie :
optIdx = OV_RA_STEAL_DIE_MONSTER;
break;
case Opt_Bracelet_Steal_SAPoint_MonsterDie :
optIdx = OV_SA_STEAL_DIE_MONSTER;
break;
case Opt_Gloves_Add_LootExp:
case Opt_Bracelet_Mul_LootExp:
optIdx = OV_ADD_EXP_RATE;
break;
case Opt_Bracelet_Mul_LootGenExp:
optIdx = OV_ADD_GENEXP_RATE;
break;
case Opt_Upper_Add_LootNak:
case Opt_Bracelet_Mul_LootNak:
optIdx = OV_ADD_NAK_RATE;
break;
default :
continue;
break;
}
if( optIdx >= 0 ) g_optValue[optIdx] += optValue;
}
return( 1 );
}
void OPTION_ApplyItem( item_t* item )
{
float backupOptValue[NUM_OPTION_VALUE];
int idx = item->itemTableIdx;
int classIdx = g_itemTable[idx].classIdx;
memcpy( &g_oriItem, &g_itemTable[idx], sizeof( itemTable_t ) );
memcpy( &g_optItem, &g_itemTable[idx], sizeof( itemTable_t ) );
memcpy( &backupOptValue, &g_optValue, sizeof( g_optValue ) );
OPTION_InitGlobal();
OPTION_ApplyItemOption( item );
g_optItem.atkPhyMinDmg += (int)g_optValue[OV_W_MIN_PHYDMG];
g_optItem.atkPhyMaxDmg += (int)g_optValue[OV_W_MAX_PHYDMG];
g_optItem.atkPhyMinDmg += (int)g_optValue[OV_W_PHYDMG];
g_optItem.atkPhyMaxDmg += (int)g_optValue[OV_W_PHYDMG];
g_optItem.atkMagMinDmg += (int)g_optValue[OV_W_MIN_MAGDMG];
g_optItem.atkMagMaxDmg += (int)g_optValue[OV_W_MAX_MAGDMG];
g_optItem.atkMagMinDmg += (int)g_optValue[OV_W_MAGDMG];
g_optItem.atkMagMaxDmg += (int)g_optValue[OV_W_MAGDMG];
if( g_itemClassTable[classIdx].attackAtt )
{
g_optItem.atkHitPower += (int)g_optValue[OV_W_HITPOWER];
}
else if( g_itemClassTable[classIdx].defenseAtt )
{
g_optItem.defHitPower += (int)g_optValue[OV_W_HITPOWER];
}
g_optItem.defVelocity += (int)g_optValue[OV_VELOCITY];
g_optItem.defAvoidPower += (int)g_optValue[OV_AVOIDPOWER];
g_optItem.atkDelay += (int)g_optValue[OV_W_ATKSPEED];
g_optItem.defPower += (int)g_optValue[OV_D_DEFPOWER];
if( g_optItem.atkPhyMinDmg > g_optItem.atkPhyMaxDmg )
{
g_optItem.atkPhyMinDmg = g_optItem.atkPhyMaxDmg;
}
if( g_optItem.atkMagMinDmg > g_optItem.atkMagMaxDmg )
{
g_optItem.atkMagMinDmg = g_optItem.atkMagMaxDmg;
}
memcpy( &g_optValue, &backupOptValue, sizeof( g_optValue ) );
}
void OPTION_CheckOptionValue( float optValue[] )
{
}
| C++ |
#if !defined(AFX_POSTSYSTEM_H__9C90C004_6FE9_43AF_AD79_A1E4ACE78D18__INCLUDED_)
#define AFX_POSTSYSTEM_H__9C90C004_6FE9_43AF_AD79_A1E4ACE78D18__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include <VECTOR>
#include "global_def.h"
#define IDSTRING 20
#define PASSWORDSTRING 20
#define NAMESTRING 20
#define WORLDNAMESTRING 64
class CPostManager
{
public:
enum
{
MAX_POSTPACKAGE_COUNT = 50,
POST_SENDTIME_INFO_STR_LEN = 32,
POST_TITLESIZE = 32,
POST_STRSIZE = 2000,
MAX_ITEMCOUNT_IN_POSTPACKAGE= 12,
MAX_MESSAGE_LINE = 6,
};
enum enumPostPackageState
{
POSTPACKAGE_UNCHECK = 0,
POSTPACKAGE_CHECK,
};
enum enumPostPackageMode
{
POSTSYSTEM_READMODE,
POSTSYSTEM_WRITEMODE
};
enum enumPostSendType
{
POST_SENDTYPE_WEB,
POST_SENDTYPE_CHAR
};
public:
struct PostPackage_t{
BOOL bActive;
int iPostIdx;
char szFromName [NAMESTRING+1];
char szFromAccountID [IDSTRING+1];
char szPostTitle [POST_TITLESIZE+1];
char szSendPostTime [POST_SENDTIME_INFO_STR_LEN+1];
char szMailStr [POST_STRSIZE+1];
item_t Items [MAX_ITEMCOUNT_IN_POSTPACKAGE];
UINT ItemNumber;
enum enumPostPackageState MailState;
enum enumPostSendType PostSendType;
int iRemainDays;
int Nak;
bool bCheck;
};
protected:
enumPostPackageMode m_PostSystemState;
std::vector<PostPackage_t> m_PostEntity;
PostPackage_t* m_pOpenPost;
public:
int m_OpenPostIdx;
public:
void InverseState(void);
int GetState();
PostPackage_t* GetPostPackage(int Idx);
int GetPostCount();
PostPackage_t* GetOpenPost();
int GetCheckCount();
bool SetPostPackage(PostPackage_t*);
void AddPostPackage(const PostPackage_t&);
bool DeletePostPackage(int postidx);
void SetOpenPost(int idx);
bool IsValidPost(int idx);
BOOL InitPackage(PostPackage_t* pPostPackage);
void SetPostSystem(enumPostPackageMode);
public:
void InitPostSystem();
public:
CPostManager();
virtual ~CPostManager();
};
#endif
| C++ |
#if !defined(AFX_ITEMTABLEDATA_H__F3A4BC8C_A73C_4E43_8CDD_2296573B32B0__INCLUDED_)
#define AFX_ITEMTABLEDATA_H__F3A4BC8C_A73C_4E43_8CDD_2296573B32B0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItemTableData
{
public:
enum ItemTable_FluxDataType
{
NONE_TYPE=0,
USE_ITEM_FOR_EPK_CHARGE=2,
USE_ITEM_FOR_EPK_MUCH_CHARGE=3,
USE_ITEM_FOR_REPAIR=4,
USE_ITEM_FOR_WEATHER_SNOW=5,
USE_ITEM_FOR_WEATHER_RAIN=6,
USE_ITEM_FOR_QUESTSCROLL=7,
USE_ITEM_FOR_AUTOQUESTSCROLL=8,
USE_ITEM_FOR_SURGERY=9,
USE_ITEM_FOR_CHAT=10,
USE_ITEM_FOR_RECYCLE=11,
USE_ITEM_FOR_SURGERY_MAXHAIRCOUNT_TYPE=12,
USE_ITEM_FOR_SUMMONCARD_ITEM = 13,
USE_ITEM_FOR_OPTION_MANAGE = 14,
USE_ITEM_FOR_AWAKEN = 15,
USE_ITEM_FOR_PC_SUMMON = 16,
USE_ITEM_FOR_PC_MOVE_SUMMON =17,
MAX_ITEM_TABLE_TYPE_DATA,
};
enum ItemTable_FluxDataValue
{
EPK_RATIO=101,
LPACK_TAB=102,
LPACK_INDEX=103,
RECYCLE_DURABILITY_MULTIPLY=104,
RECYCLE_LEVEL_MULTIPLY=105,
RECYCLE_LEVEL_EXP_MULTIPLY=106,
RECYCLE_LEVEL_GENEXP_MULTIPLY=107,
RECYCLE_PARAM_ITEM_FUNCTION=108,
RECYCLE_LEVEL_EXP_AND_GENEXP_MULTIPLY=109,
EPK_NOT_MORE_CHARGE_IS_DELETE=110,
RECYCLE_RA_CHARGE=111,
RECYCLE_SA_CHARGE=112,
RECYCLE_GEN_CAPABLITY=113,
RECYCLE_DESTROYITEM=114,
RUN_SKILL_ITEM=115,
RUN_SKILL_INDEX=116,
RUN_SKILL_ADD_LEVEL=117,
OPTION_MANAGE_TYPE= 118,
EFFECT_ID =119,
MAX_ITEMTABLE_DATA_TYPE,
};
enum Surgery_HairItem_Type
{
SURGERY1=0,
SURGERY2,
};
public:
float GetData(const itemTable_t *_pItemTable,const int _Type);
bool IsType(const itemTable_t *_pItemTable,const int _Type);
int GetUseItemType(const itemTable_t *_pItemTable);
float GetData(const int _ItemTableIndex ,const int _Type);
public:
CItemTableData();
virtual ~CItemTableData();
};
#endif
| C++ |
#include "../global_def.h"
CChristMasEvent::CChristMasEvent()
{
m_EventState = EVENT_INACTIVE;
}
CChristMasEvent::~CChristMasEvent()
{
}
void CChristMasEvent::GTH_Process_ChristMas_Event()
{
int type = MSG_ReadByte();
switch(type)
{
case GSC_CHRISTMAS_EVENT_REPLY_USE_SNOWITEM:
GTH_ProcessMessage_Reply_ChristMas_UseItem();
break;
case GSC_CHRISTMAS_EVENT_REPLY_CHRISTEVENT:
GTH_ProcessMessage_ChristMasEvent();
break;
case GSC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE:
GTH_ProcessMessage_Request_WorldState();
break;
default:
return;
}
}
void CChristMasEvent::GTH_ProcessMessage_Reply_ChristMas_UseItem(void)
{
char str[MAX_PATH+1];
GTH_UnlockSending();
int reply = 1;
int error = 1;
reply = MSG_ReadLong();
if ( reply == 1 )
{
int invenPos;
int itemIdx;
item_t *item = NULL;
invenPos = MSG_ReadByte();
if ( invenPos < 0 )
goto error;
itemIdx = g_cgv.myCharacterInfo->inventory[invenPos];
if ( itemIdx < 0 )
goto error;
item = &g_cgv.myCharacterInfo->item[itemIdx];
if ( item == NULL)
goto error;
if( item->durability > 0 )
{
item->durability --;
}
else
{
GTH_DeleteMyItem( &g_cgv.myCharacterInfo->item[itemIdx] );
g_cgv.myCharacterInfo->inventory[invenPos] = -1;
}
sprintf(str, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 247), g_cgv.myCharacterInfo->name,
g_cgv.worldTable[g_cgv.syncCharacter[0].worldIdx].hanName);
str[MAX_PATH] = NULL;
GTH_SendUserNotice(str);
return;
}
else
{
error = MSG_ReadLong();
switch(error)
{
case ERROR_CHRISTMAS_EVENT_USE_ITEM:
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL, 395));
}
break;
case ERROR_CHRISTMAS_EVENT_USE_ITEM2:
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 248));
}
break;
}
return;
}
error:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL, 395));
}
void CChristMasEvent::GTH_SendMessage_Request_ChristMas_UseItem(int invenpos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_REQUEST_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_EVENT_REQUEST_USE_SNOWITEM);
MSG_WriteByte(&netMessage, invenpos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CChristMasEvent::GTH_ProcessMessage_ChristMasEvent(void)
{
int state = MSG_ReadLong();
m_EventState = static_cast<enumChristMasEventState>(MSG_ReadLong());
int worldidx = -1;
if ( state == (int)CHRISTMAS_EVENT_WORLD_PROGRESS)
{
g_timeSystem->SetTimeStateEnv (TIME_SNOW);
}
else
{
g_timeSystem->SetTimeStateEnv (TIME_DAY);
}
}
void CChristMasEvent::GTH_SendMessageEventSeting(int event)
{
if ( event < 0)
event = 0;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_REQUEST_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_BROAD_CASTING_EVENT_SETING);
MSG_WriteByte(&netMessage, event);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
if ( event == 0)
{
g_ifMng->AddChatMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 251), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322));
}
else
{
g_ifMng->AddChatMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 252), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322));
}
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_WARNING_2 ), GTH_SOUND_PLAY_ONCE );
}
void CChristMasEvent::GTH_SendMessage_Request_WorldState(int worldidx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_REQUEST_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE);
MSG_WriteByte(&netMessage, worldidx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CChristMasEvent::GTH_ProcessMessage_Request_WorldState()
{
int reply = MSG_ReadByte();
int state = 0;
if ( reply == 1)
{
state = MSG_ReadLong();
if ( state == CHRISTMAS_EVENT_WORLD_PROGRESS)
{
g_timeSystem->SetTimeStateEnv (TIME_SNOW);
}
else
{
g_timeSystem->SetTimeStateEnv (TIME_DAY);
}
m_EventState = EVENT_ACTIVE;
}
else
{
g_timeSystem->SetTimeStateEnv (TIME_DAY);
}
}
void CChristMasEvent::GTH_SendUserNotice(char *notice)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_REQUEST_CHRISTMAS_EVENT);
MSG_WriteByte(&netMessage, CC_CHRISTMAS_EVENT_NOTICE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#include "../global_def.h"
CPostManager::CPostManager()
{
m_OpenPostIdx = -1;
}
CPostManager::~CPostManager(){}
void CPostManager::AddPostPackage(const PostPackage_t& postpackage)
{
m_PostEntity.push_back(postpackage);
}
bool CPostManager::DeletePostPackage(int postidx)
{
for (int Postcount = 0; Postcount < m_PostEntity.size(); Postcount++)
{
if ( m_PostEntity[Postcount].iPostIdx == postidx )
{
m_PostEntity.erase(&m_PostEntity[Postcount]);
return 1;
}
}
return 0;
}
void CPostManager::InitPostSystem()
{
m_PostEntity.erase(m_PostEntity.begin(), m_PostEntity.end());
m_PostSystemState = POSTSYSTEM_READMODE;
m_pOpenPost = NULL;
m_OpenPostIdx = -1;
}
void CPostManager::InverseState()
{
if(m_PostSystemState == POSTSYSTEM_READMODE)
m_PostSystemState = POSTSYSTEM_WRITEMODE;
else
m_PostSystemState = POSTSYSTEM_READMODE;
}
int CPostManager::GetState()
{
return m_PostSystemState;
}
int CPostManager::GetPostCount()
{
return m_PostEntity.size();
}
CPostManager::PostPackage_t* CPostManager::GetPostPackage(int Idx)
{
if ( m_PostEntity.size() <= Idx )
return NULL;
return & m_PostEntity[Idx];
}
void CPostManager::SetOpenPost(int idx)
{
m_pOpenPost = GetPostPackage(idx);
m_OpenPostIdx = idx;
}
CPostManager::PostPackage_t* CPostManager::GetOpenPost()
{
return m_pOpenPost ;
}
bool CPostManager::IsValidPost(int Idx)
{
if ( &m_PostEntity[Idx] == NULL)
return 0;
if ( m_PostEntity[Idx].iPostIdx < 0)
return 0;
if ( strlen(m_PostEntity[Idx].szFromName) == 0 )
return 0;
if ( strlen(m_PostEntity[Idx].szSendPostTime) == 0 )
return 0;
return 1;
}
int CPostManager::GetCheckCount()
{
int Count = 0;
int MaxPostCount = GetPostCount();
CPostManager::PostPackage_t* pPostPackage = NULL;
for (int CheckIdx = 0; CheckIdx < MaxPostCount; CheckIdx ++)
{
pPostPackage = GetPostPackage(CheckIdx);
if ( pPostPackage == NULL)
continue;
if ( pPostPackage->bCheck )
Count++;
}
return Count;
}
BOOL CPostManager::InitPackage(PostPackage_t* pPostPackage)
{
if ( pPostPackage == NULL )
return FALSE;
memset(pPostPackage, 0, sizeof(PostPackage_t));
pPostPackage->bActive = 0;
pPostPackage->bCheck = 0;
pPostPackage->iPostIdx = -1;
pPostPackage->iRemainDays = 0;
pPostPackage->ItemNumber = 0;
for (int ItemIdx = 0; ItemIdx< CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; ItemIdx++)
pPostPackage->Items[ItemIdx].itemTableIdx = -1;
pPostPackage->MailState = CPostManager::enumPostPackageState::POSTPACKAGE_UNCHECK;
pPostPackage->Nak= 0;
pPostPackage->PostSendType = CPostManager::enumPostSendType::POST_SENDTYPE_CHAR;
return TRUE;
}
void CPostManager::SetPostSystem(enumPostPackageMode mode)
{
m_PostSystemState = mode;
}
| C++ |
#include "../global_def.h"
#include "../game/GolryunBattle/GolryunBattle_Decoder.h"
CGolryunBattle_Decoder g_GolryunBattle_Decoder;
CGolryunBattle_Decoder::CGolryunBattle_Decoder()
{
}
CGolryunBattle_Decoder::~CGolryunBattle_Decoder()
{
}
void CGolryunBattle_Decoder::RecvGolryunBattle()
{
BYTE bCommand;
bCommand = MSG_ReadByte();
switch (bCommand)
{
case tagGolryun_Packet_Status::GB_REQUEST_START_COUNT: RecvEffectCount(); break;
case tagGolryun_Packet_Status::GB_REQUEST_PROGRESS_MATCH: RecvStartMatch(); break;
case tagGolryun_Packet_Status::GB_REQUEST_END_MATCH: RecvEndMatch(); break;
case tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT: RecvCancelTournament(); break;
case tagGolryun_Packet_Status::GB_ERROR_CODE: RecvErrorCode(); break;
case tagGolryun_Packet_Status::GB_TRANS_GOLRYUN: RecvTransGolryun(); break;
case tagGolryun_Packet_Status::GB_TRANS_ARAYAN: RecvTransArayan(); break;
case tagGolryun_Packet_Status::GB_SUGGEST_BATTLE: RecvSuggestBattle(); break;
case tagGolryun_Packet_Status::GB_EFFECT_RESULT: RecvEffectResult(); break;
case tagGolryun_Packet_Status::GB_OPEN_BATTLE_TICKET: RecvOpenBattleTicket(); break;
case tagGolryun_Packet_Status::GB_SHARE_RATE: RecvShareRate(); break;
case tagGolryun_Packet_Status::GB_RENEW_BATTLE_TICKET: RecvReNewBattleTicket(); break;
case tagGolryun_Packet_Status::GB_OPEN_SHARE_WIN: RecvOpenShareWin(); break;
case tagGolryun_Packet_Status::GB_DISPLAY_TOURNAMENT: RecvDisplayTournament(); break;
case tagGolryun_Packet_Status::GB_CHECK_PRIZE: RecvCheckPrize(); break;
case tagGolryun_Packet_Status::GB_LOCAL_USER_NOTICE: RecvLocalUserNotice(); break;
case tagGolryun_Packet_Status::GB_ALL_USER_DATA: RecvAllUserData(); break;
case tagGolryun_Packet_Status::GB_START_MATCH_NOTICE: RecvStartMatchNotice(); break;
case tagGolryun_Packet_Status::GB_END_MATCH_NOTICE: RecvEndMatchNotice(); break;
case tagGolryun_Packet_Status::GB_BATTLE_RASA_Sync: RecvSyncRASAMatch(); break;
case tagGolryun_Packet_Status::GB_CHECK_JOINER_NUM: RecvCheckJoinerNum(); break;
case tagGolryun_Packet_Status::GB_STATUS_MATCH_NOTICE: RecvStatusMatchNotice(); break;
case tagGolryun_Packet_Status::GB_NOTICE_BATTLE: RecvNoticeBattle(); break;
case tagGolryun_Packet_Status::GB_BUY_BATTLE_TICKET: RecvBuyBattleTicket(); break;
case tagGolryun_Packet_Status::GB_TWOGYUN_TOTAL_NAK: RecvTwoGyunTotalNak(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_START: RecvObserveStart(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_END: RecvObserveEnd(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_MATCH_TIME: RecvObserveMatchTime(); break;
case tagGolryun_Packet_Status::GB_MATCH_PROGRESS_TIME: RecvMatchProgressTime(); break;
case tagGolryun_Packet_Status::GB_GM_NOTICE: RecvMessageToGM(); break;
}
}
void CGolryunBattle_Decoder::RecvMessageToGM()
{
int LpackIdx = MSG_ReadLong();
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_GOLRYUN_BATTLE, LpackIdx ));
}
void CGolryunBattle_Decoder::RecvObserveMatchTime()
{
int remainTime = MSG_ReadLong();
if(remainTime<0) remainTime = 0;
g_ifMng->m_observerInfoWin->m_RemainTime = remainTime;
}
void CGolryunBattle_Decoder::RecvObserveEnd()
{
GTH_UnlockSending();
BOOL bSuccess = MSG_ReadByte();
if(FALSE == bSuccess){
g_pApp->m_bAppExit = TRUE;
PostMessage(g_pApp->m_hWnd,WM_CLOSE,0,0);
return;
}
g_GolryunBattle.SetObserverMode(CGolryunBattle::eObserverMode::general);
memcpy(g_pApp->m_myCharacter->position, g_GolryunBattle.m_OldPosition, sizeof(vec3_t));
g_pApp->m_myCharacter->m_bObserveMode = FALSE;
g_camera.m_maxCamDist = -350.0f;
g_camera.m_distance = -350.0f;
g_ifMng->m_observerInfoWin->m_RemainTime = 0;
g_ifMng->m_observerInfoWin->m_redFighterNumber = 0;
g_ifMng->m_observerInfoWin->m_blueFighterNumber = 0;
for( int i = 0; i < NUM_IF_WINDOW_TYPE; i ++ )
{
if(g_ifMng->m_winControl[i]->BeforeState())
{
g_ifMng->m_winControl[i]->SetBeforeState(false);
g_ifMng->m_winControl[i]->Enable(true);
}
}
g_ifMng->m_observerMenuWin->Enable(false);
g_ifMng->m_observerInfoWin->Enable(false);
g_ifMng->m_tournamentMiniWin->Enable(false);
g_ifMng->m_battleTicketWin->Enable(false);
g_ifMng->m_shareWin->Enable(false);
}
void CGolryunBattle_Decoder::RecvObserveStart()
{
BOOL bSuccess = MSG_ReadByte();
if(FALSE == bSuccess && FALSE == g_pApp->m_myCharacter->m_bWaitingRoom){
g_pApp->m_bAppExit = TRUE;
PostMessage(g_pApp->m_hWnd,WM_CLOSE,0,0);
return;
}
g_GolryunBattle.SetObserverMode(CGolryunBattle::eObserverMode::observe);
g_camera.m_maxCamDist = -700.0f;
memcpy(g_GolryunBattle.m_OldPosition, g_pApp->m_myCharacter->position, sizeof(vec3_t));
g_pApp->m_myCharacter->position[0] = 2108;
g_pApp->m_myCharacter->position[1] = -11771;
g_pApp->m_myCharacter->position[2] = -300;
g_GolryunBattle.m_ObserverPos[0] = 2108;
g_GolryunBattle.m_ObserverPos[1] = -11771;
g_GolryunBattle.m_ObserverPos[2] = 180;
g_pApp->m_myCharacter->m_bObserveMode = TRUE;
g_ifMng->m_chatWin->Enable( false );
for( int i = 0; i < NUM_IF_WINDOW_TYPE; i ++ )
{
if(g_ifMng->m_winControl[i]->State())
{
g_ifMng->m_winControl[i]->SetBeforeState(true);
g_ifMng->m_winControl[i]->Enable(false);
}
}
g_ifMng->m_dlgWin->Enable(true);
g_ifMng->m_observerMenuWin->Enable(true);
g_ifMng->m_observerInfoWin->Enable(true);
}
void CGolryunBattle_Decoder::RecvTwoGyunTotalNak(void)
{
int totalNak = MSG_ReadLong();
char szTemp[256];
sprintf( szTemp, "Total Income Nak: %s", g_ifMng->GetNumberString( totalNak ) );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp);
}
void CGolryunBattle_Decoder::RecvNoticeBattle(void)
{
char notice[256];
strcpy(notice, MSG_ReadString());
g_ifMng->AddNoticeMessage( notice, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle_Decoder::RecvStatusMatchNotice(void)
{
int noticeIdx = MSG_ReadShort();
char szTemp[255];
switch(noticeIdx)
{
case 1:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,361) );
break;
case 4:
case 2:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,362) );
break;
case 3:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,363) );
break;
}
g_ifMng->AddSysMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle_Decoder::RecvSyncRASAMatch(void)
{
g_pApp->m_myCharacter->curRA = MSG_ReadLong();
g_pApp->m_myCharacter->curSA = MSG_ReadShort();
g_pApp->m_myCharacter->calMaxRA = MSG_ReadLong();
g_pApp->m_myCharacter->calMaxSA = MSG_ReadShort();
}
void CGolryunBattle_Decoder::RecvCheckJoinerNum(void)
{
int joinNum = MSG_ReadShort();
char szTemp[256];
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,364), joinNum);
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp);
}
void CGolryunBattle_Decoder::RecvStartMatchNotice(void)
{
g_ifMng->m_observerInfoWin->m_redFighterNumber = MSG_ReadShort();
g_ifMng->m_observerInfoWin->m_blueFighterNumber = MSG_ReadShort();
}
void CGolryunBattle_Decoder::RecvEndMatchNotice(void)
{
if(g_ifMng->m_tournamentWin->State() || g_ifMng->m_tournamentMiniWin->State()){
g_GolryunBattle_Encoder.SendReNewDisplayTournament();
}
if(g_ifMng->m_observerInfoWin->State()){
g_ifMng->m_observerInfoWin->m_RemainTime = 0;
g_ifMng->m_observerInfoWin->m_redFighterNumber = 0;
g_ifMng->m_observerInfoWin->m_blueFighterNumber = 0;
}
}
void CGolryunBattle_Decoder::RecvReNewBattleTicket(void)
{
if(g_ifMng->m_battleTicketWin->State()){
g_GolryunBattle_Encoder.SendReNewBattleTicket();
}
}
void CGolryunBattle_Decoder::RecvErrorCode()
{
BYTE eCode = MSG_ReadByte();
BYTE eType = MSG_ReadByte();
char szTemp[256];
int level;
int iTournamentIdx = g_GolryunBattle.GetTournamentIdx();
switch(eType)
{
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_1:
level = g_golryunManagerTable[iTournamentIdx].levelMin;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,147), level );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_2:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL,36));
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_3:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,366) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_4:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,367) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_5:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,368) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_6:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,369) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_7:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,345) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_8:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL,49));
break;
}
}
void CGolryunBattle_Decoder::RecvLocalUserNotice()
{
int lpackIdx = MSG_ReadShort();
char szTemp[255];
int iTournamentIdx = g_GolryunBattle.GetTournamentIdx();
switch(lpackIdx)
{
case 151:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,151), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 152:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,152), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 158:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,158), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 159:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,159), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 160:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,160), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 161:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,161), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 162:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,162), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 209:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,209), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 210:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,210), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 163:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,163), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 164:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,164), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 166:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,166), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 167:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,167));
break;
case 169:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,169), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
case 370:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,370), g_golryunManagerTable[iTournamentIdx].levelMin );
break;
}
g_ifMng->AddNoticeMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
g_ifMng->AddSysMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle_Decoder::RecvAllUserData()
{
int iTournamentIdx = MSG_ReadShort();
g_GolryunBattle.SetTournamentIdx(iTournamentIdx);
}
void CGolryunBattle_Decoder::RecvTransGolryun()
{
int iTournamentIdx = MSG_ReadShort();
g_GolryunBattle.SetTournamentIdx(iTournamentIdx);
int iBattleIdx = MSG_ReadShort();
g_GolryunBattle.SetBattleIdx(iBattleIdx);
g_GolryunBattle.ProcessTransGolryunBattle();
}
void CGolryunBattle_Decoder::RecvTransArayan()
{
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,373),
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_TRANSPORT_ARAYAN_ACCEPT );
}
void CGolryunBattle_Decoder::RecvSuggestBattle()
{
char szTemp[256];
int level, deposit;
BYTE eType = MSG_ReadByte();
int iBattleIdx = MSG_ReadShort();
g_GolryunBattle.SetBattleIdx(iBattleIdx);
int iTournamentIdx = MSG_ReadShort();
g_GolryunBattle.SetTournamentIdx(iTournamentIdx);
switch(eType)
{
case 0:
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,374));
break;
case 1:
level = g_golryunManagerTable[iTournamentIdx].levelMin;
deposit = g_golryunManagerTable[iTournamentIdx].deposit;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,149), level, deposit );
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), szTemp,
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_GB_BATTLE_SUGGEST_ACCEPT );
break;
case 2:
level = g_golryunManagerTable[iTournamentIdx].levelMin;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,147), level );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp );
break;
}
g_ifMng->m_chatWin->Enable( false );
}
void CGolryunBattle_Decoder::RecvOpenBattleTicket()
{
GTH_UnlockSending();
BYTE eType = MSG_ReadByte();
if(eType)
{
CGolryunBattle::tagTournament* pTournament = g_GolryunBattle.GetTournamentPointer();
pTournament->m_iTournamentGUID = MSG_ReadShort();
int iBattleIdx = MSG_ReadShort();
g_GolryunBattle.SetBattleIdx(iBattleIdx);
int iTournamentIdx = MSG_ReadShort();
g_GolryunBattle.SetTournamentIdx(iTournamentIdx);
g_ifMng->m_battleTicketWin->m_JoinerCnt = MSG_ReadShort();
if(g_ifMng->m_battleTicketWin->m_JoinerCnt > CGolryunBattle::MAX_NUM_FIGHTER_PER_TOURNAMENT)
g_ifMng->m_battleTicketWin->m_JoinerCnt = CGolryunBattle::MAX_NUM_FIGHTER_PER_TOURNAMENT;
for(int i=0; i<g_ifMng->m_battleTicketWin->m_JoinerCnt; i++)
{
g_ifMng->m_battleTicketWin->m_ticketList[i].num = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].job = MSG_ReadByte();
g_ifMng->m_battleTicketWin->m_ticketList[i].win = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].lose = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].shareRate = MSG_ReadFloat();
}
g_ifMng->m_battleTicketWin->m_winNumber = 0;
g_ifMng->m_battleTicketWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_battleTicketWin );
}
else
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,375));
}
g_ifMng->m_chatWin->Enable( false );
}
void CGolryunBattle_Decoder::RecvBuyBattleTicket()
{
g_cgv.myCharacterInfo->curChargeSE = MSG_ReadLong();
}
void CGolryunBattle_Decoder::RecvShareRate()
{
for(int i=0; i<g_ifMng->m_battleTicketWin->m_JoinerCnt; i++)
{
g_ifMng->m_battleTicketWin->m_ticketList[i].shareRate = MSG_ReadFloat();
}
}
void CGolryunBattle_Decoder::RecvOpenShareWin()
{
GTH_UnlockSending();
int iBattleIdx = MSG_ReadShort();
g_GolryunBattle.SetBattleIdx(iBattleIdx);
CGolryunBattle::tagBattle* pBattle = g_GolryunBattle.GetBattleCurrentPointer();
for(int i=0; i<CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
pBattle->Tournament[i].bComplete = MSG_ReadByte();
pBattle->Tournament[i].m_iTournamentGUID = MSG_ReadShort();
pBattle->Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
pBattle->Tournament[i].m_ShareRate = MSG_ReadFloat();
}
int recordIdx=0;
if(iBattleIdx>CGolryunBattle::MAX_NUM_BATTLE_RECORD) recordIdx = CGolryunBattle::MAX_NUM_BATTLE_RECORD;
else recordIdx = iBattleIdx-1;
for(int idx=0; idx<recordIdx; idx++)
{
CGolryunBattle::tagBattle* pBattleRecord = g_GolryunBattle.GetBattleRecordPointer(idx);
for(int i=0; i<CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
pBattleRecord->m_iBattleGUID = MSG_ReadShort();
pBattleRecord->Tournament[i].bComplete = MSG_ReadByte();
pBattleRecord->Tournament[i].m_iTournamentGUID = MSG_ReadShort();
pBattleRecord->Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
pBattleRecord->Tournament[i].m_ShareRate = MSG_ReadFloat();
}
}
g_ifMng->m_shareWin->m_iBattleCnt = iBattleIdx;
g_ifMng->m_shareWin->InitShareInventory();
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_shareWin->Enable();
g_ifMng->m_itemWin->Enable();
g_ifMng->SetFocus( g_ifMng->m_shareWin );
}
void CGolryunBattle_Decoder::RecvDisplayTournament()
{
GTH_UnlockSending();
int i,j;
int iTournamentIdx = MSG_ReadShort();
g_GolryunBattle.SetTournamentIdx(iTournamentIdx);
CGolryunBattle::tagBattle* pBattle=NULL;
pBattle = g_GolryunBattle.GetBattleCurrentPointer();
for(i=0; i<CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
pBattle->Tournament[i].bComplete = MSG_ReadByte();
pBattle->Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
}
CGolryunBattle::tagMatch* pMatch=NULL;
for (i=0;i<CGolryunBattle::MAX_NUM_MATCH_PER_TOURNAMENT;i++)
{
pMatch = g_GolryunBattle.GetMatchPointer(i);
pMatch->bComplete = MSG_ReadByte();
for (j=0;j<2;j++)
{
pMatch->Fighter[j].iFightNum = MSG_ReadShort();
pMatch->Fighter[j].bWin = MSG_ReadByte();
}
}
CGolryunBattle::tagTournament* pTournament=NULL;
pTournament = g_GolryunBattle.GetTournamentPointer();
pTournament->FirstWinner.iFightNum = MSG_ReadShort();
g_ifMng->m_chatWin->Enable( false );
if(g_pApp->m_myCharacter->m_bObserveMode)
{
g_ifMng->m_tournamentMiniWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_tournamentMiniWin );
}
else
{
g_ifMng->m_tournamentWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_tournamentWin );
}
}
void CGolryunBattle_Decoder::RecvCheckPrize()
{
CGolryunBattle::tagBattle* pBattle=NULL;
pBattle = g_GolryunBattle.GetBattleCurrentPointer();
for(int i=0; i<CGolryunBattle::MAX_NUM_PRIZE_LIST_PER_BATTLE; i++)
{
pBattle->m_PrizeNumber[i] = MSG_ReadShort();
}
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_prizeWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_prizeWin );
}
void CGolryunBattle_Decoder::RecvEffectCount()
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->angles[YAW] = MSG_ReadShort();
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_COUNT);
g_input->MouseEnable(false);
g_input->KeyEnable(false);
g_ifMng->m_tournamentWin->Enable(false);
g_ifMng->m_battleTicketWin->Enable(false);
g_ifMng->m_shareWin->Enable(false);
}
void CGolryunBattle_Decoder::RecvMatchProgressTime()
{
g_ifMng->m_golryunInfoWin->m_RemainTime = MSG_ReadLong();
}
void CGolryunBattle_Decoder::RecvStartMatch()
{
g_ifMng->m_golryunInfoWin->m_RemainTime = MSG_ReadLong();
g_ifMng->m_golryunInfoWin->Enable(true);
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_golryunInfoWin );
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_PROGRESS_MATCH);
}
void CGolryunBattle_Decoder::RecvEndMatch()
{
g_pApp->m_myCharacter->pvpMode = false;
g_musicMng->ChangeBGMusic( g_pApp->m_mapInfos[ 0 ].BGMusic );
g_ifMng->m_golryunInfoWin->m_RemainTime=0;
g_ifMng->m_golryunInfoWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_END_MATCH);
}
void CGolryunBattle_Decoder::RecvCancelTournament()
{
g_ifMng->m_golryunInfoWin->m_RemainTime=0;
g_ifMng->m_golryunInfoWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
g_pApp->m_myCharacter->m_bWaitingRoom = FALSE;
g_pApp->m_myCharacter->pvpMode = false;
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT);
}
void CGolryunBattle_Decoder::RecvJoinNumber()
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->m_JoinNum = MSG_ReadShort();
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_BETTING);
}
void CGolryunBattle_Decoder::RecvEffectResult()
{
int index = MSG_ReadShort();
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->angles[YAW] = 90;
VectorCopy( g_camera.m_angles, myChar->angles );
g_camera.m_angles[YAW] = myChar->angles[YAW] + 180.0f;
int effIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
index,
myChar->position,
NULL,
true,
myChar->entityType,
myChar->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
switch(index)
{
case 66:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_SUCCESS ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
case 67:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_FAIL ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
case 68:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_CONG ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
}
}
| C++ |
#include "../global_def.h"
#include "GolryunBattle.h"
#include "GolryunBattle_Encoder.h"
CGolryunBattle g_GolryunBattle;
CGolryunBattle::CGolryunBattle()
{
m_iUpdateTime=0;
m_iStartTime=0;
m_iStartCnt=0;
m_iTournamentIdx = 0;
m_iBattleIdx=1;
memset(m_OldPosition, 0, sizeof(vec3_t));
memset(m_ObserverPos, 0, sizeof(vec3_t));
m_Match = new tagMatch[MAX_NUM_MATCH_PER_TOURNAMENT];
m_Tournament = new tagTournament;
m_BattleCurrent = new tagBattle;
m_BattleRecord = new tagBattle[MAX_NUM_BATTLE_RECORD];
InitMatch();
InitTournament(m_Tournament);
InitBattle(m_BattleCurrent);
InitBattleRecord();
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_INIT_BATTLE);
SetObserverMode(eObserverMode::general);
}
CGolryunBattle::~CGolryunBattle()
{
delete[] m_Match;
delete m_Tournament;
delete m_BattleCurrent;
delete[] m_BattleRecord;
}
void CGolryunBattle::InitMatch()
{
int i,j;
for (i=0;i<MAX_NUM_MATCH_PER_TOURNAMENT;i++)
{
m_Match[i].bComplete = false;
for (j=0;j<2;j++)
{
m_Match[i].Fighter[j].iFightNum = -1;
m_Match[i].Fighter[j].bWin = false;
}
}
}
int CGolryunBattle::InitTournament(tagTournament* pTournament)
{
pTournament->bComplete = false;
pTournament->m_iTournamentGUID = 0;
pTournament->m_ShareRate = 0.0f;
pTournament->FirstWinner.iFightNum = -1;
pTournament->FirstWinner.bWin = false;
pTournament->SecondWinner.iFightNum = -1;
pTournament->SecondWinner.bWin = false;
return TRUE;
}
void CGolryunBattle::InitBattle(tagBattle* pBattle)
{
pBattle->bComplete = false;
pBattle->m_iBattleGUID = 0;
memset(pBattle->m_PrizeNumber, 0, sizeof(int)*MAX_NUM_PRIZE_LIST_PER_BATTLE);
int tournamentIdx;
for(tournamentIdx=0; tournamentIdx<MAX_NUM_TOURNAMENT_PER_BATTLE; tournamentIdx++)
{
InitTournament(&pBattle->Tournament[tournamentIdx]);
}
}
void CGolryunBattle::InitBattleRecord()
{
int battIdx;
for(battIdx=0; battIdx<MAX_NUM_BATTLE_RECORD; battIdx++)
{
InitBattle(&m_BattleRecord[battIdx]);
}
}
void CGolryunBattle::SetStatus(int iStatus)
{
m_iStatus = iStatus;
m_iStartTime = m_iUpdateTime;
}
int CGolryunBattle::GetStatus()
{
return m_iStatus;
}
void CGolryunBattle::SendRequestStartBattle(int iManorIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_BATTLE);
MSG_WriteShort(&netMessage, iManorIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestStartJoin()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_JOIN);
MSG_WriteShort(&netMessage, m_iTournamentIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestStartReCallFighter()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_START_RECALL_FIGHTER);
MSG_WriteShort(&netMessage, m_iTournamentIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestCloseJoin()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CLOSE_JOIN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestStartBetting()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_BETTING);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestReadyTournament()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_READY_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestStartCount()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_COUNT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestPauseMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_PAUSE_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestReStartMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RESTART_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestEndMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_END_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestWaitTournament()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_WAIT_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestCloseBattle()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CLOSE_BATTLE);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestStartPrize()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_PRIZE);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendTransWatchingRoom()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_WATCHINGROOM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendTransWaitingRoom()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_WAITINGROOM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendTransBattleStadium()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_BATTLESTADIUM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendNoticeBattle(char* notice)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_NOTICE_BATTLE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendWalkOverMatch(int joinNum)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_WALKOVER_MATCH);
MSG_WriteShort(&netMessage, joinNum);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendCheckJoinerNum()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_CHECK_JOINER_NUM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendRequestCancelTournament()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendTwoGyunTotalNak()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TWOGYUN_TOTAL_NAK);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendAcceptTransGolryun()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ACCEPT_TRANS_GOLRYUN );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendAcceptToBattle()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ACCEPT_BATTLE );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendBuyBattleTicket(int itemTableIdx, int number)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_BUY_BATTLE_TICKET );
MSG_WriteShort(&netMessage, itemTableIdx );
MSG_WriteShort(&netMessage, number );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendReNewBattleTicket()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RENEW_BATTLE_TICKET );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendReNewDisplayTournament()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RENEW_DISPLAY_TOURNAMENT );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendCheckStartMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_CHECK_START_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendObserveEnd()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OBSERVE_END);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendOpenBattleTicket()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OPEN_BATTLE_TICKET);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendOpenShareWin()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OPEN_SHARE_WIN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendDisplayTournament()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_DISPLAY_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendInsertJoinList(char* name)
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_INSERT_JOIN_LIST);
MSG_WriteString(&netMessage, name);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::SendAssignFighterNumber(char* name, int number)
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ASSIGN_FIGHTER_NUMBER);
MSG_WriteString(&netMessage, name );
MSG_WriteLong(&netMessage, number );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle::RecvGolryunBattle()
{
BYTE bCommand;
bCommand = MSG_ReadByte();
switch (bCommand)
{
case tagGolryun_Packet_Status::GB_REQUEST_START_COUNT: RecvEffectCount(); break;
case tagGolryun_Packet_Status::GB_REQUEST_PROGRESS_MATCH: RecvStartMatch(); break;
case tagGolryun_Packet_Status::GB_REQUEST_END_MATCH: RecvEndMatch(); break;
case tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT: RecvInitTournament(); break;
case tagGolryun_Packet_Status::GB_ERROR_CODE: RecvErrorCode(); break;
case tagGolryun_Packet_Status::GB_TRANS_GOLRYUN: RecvTransGolryun(); break;
case tagGolryun_Packet_Status::GB_TRANS_ARAYAN: RecvTransArayan(); break;
case tagGolryun_Packet_Status::GB_SUGGEST_BATTLE: RecvSuggestBattle(); break;
case tagGolryun_Packet_Status::GB_EFFECT_RESULT: RecvEffectResult(); break;
case tagGolryun_Packet_Status::GB_OPEN_BATTLE_TICKET: RecvOpenBattleTicket(); break;
case tagGolryun_Packet_Status::GB_SHARE_RATE: RecvShareRate(); break;
case tagGolryun_Packet_Status::GB_RENEW_BATTLE_TICKET: RecvReNewBattleTicket(); break;
case tagGolryun_Packet_Status::GB_OPEN_SHARE_WIN: RecvOpenShareWin(); break;
case tagGolryun_Packet_Status::GB_DISPLAY_TOURNAMENT: RecvDisplayTournament(); break;
case tagGolryun_Packet_Status::GB_CHECK_PRIZE: RecvCheckPrize(); break;
case tagGolryun_Packet_Status::GB_LOCAL_USER_NOTICE: RecvLocalUserNotice(); break;
case tagGolryun_Packet_Status::GB_ALL_USER_DATA: RecvAllUserData(); break;
case tagGolryun_Packet_Status::GB_START_MATCH_NOTICE: RecvStartMatchNotice(); break;
case tagGolryun_Packet_Status::GB_END_MATCH_NOTICE: RecvEndMatchNotice(); break;
case tagGolryun_Packet_Status::GB_BATTLE_RASA_Sync: RecvSyncRASAMatch(); break;
case tagGolryun_Packet_Status::GB_CHECK_JOINER_NUM: RecvCheckJoinerNum(); break;
case tagGolryun_Packet_Status::GB_STATUS_MATCH_NOTICE: RecvStatusMatchNotice(); break;
case tagGolryun_Packet_Status::GB_NOTICE_BATTLE: RecvNoticeBattle(); break;
case tagGolryun_Packet_Status::GB_BUY_BATTLE_TICKET: RecvBuyBattleTicket(); break;
case tagGolryun_Packet_Status::GB_TWOGYUN_TOTAL_NAK: RecvTwoGyunTotalNak(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_START: RecvObserveStart(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_END: RecvObserveEnd(); break;
case tagGolryun_Packet_Status::GB_OBSERVE_MATCH_TIME: RecvObserveMatchTime(); break;
case tagGolryun_Packet_Status::GB_MATCH_PROGRESS_TIME: RecvMatchProgressTime(); break;
case tagGolryun_Packet_Status::GB_GM_NOTICE: RecvPauseMatchNotice(); break;
}
}
void CGolryunBattle::RecvPauseMatchNotice()
{
int LpackIdx = MSG_ReadLong();
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_GOLRYUN_BATTLE, LpackIdx ));
}
void CGolryunBattle::RecvObserveMatchTime()
{
int remainTime = MSG_ReadLong();
if(remainTime<0) remainTime = 0;
g_ifMng->m_observerInfoWin->m_RemainTime = remainTime;
}
void CGolryunBattle::RecvObserveEnd()
{
GTH_UnlockSending();
BOOL bSuccess = MSG_ReadByte();
if(FALSE == bSuccess){
g_pApp->m_bAppExit = TRUE;
PostMessage(g_pApp->m_hWnd,WM_CLOSE,0,0);
return;
}
SetObserverMode(eObserverMode::general);
memcpy(g_pApp->m_myCharacter->position, m_OldPosition, sizeof(vec3_t));
g_pApp->m_myCharacter->m_bObserveMode = FALSE;
g_camera.m_maxCamDist = -350.0f;
g_camera.m_distance = -350.0f;
g_ifMng->m_observerInfoWin->m_RemainTime = 0;
g_ifMng->m_observerInfoWin->m_redFighterNumber = 0;
g_ifMng->m_observerInfoWin->m_blueFighterNumber = 0;
for( int i = 0; i < NUM_IF_WINDOW_TYPE; i ++ )
{
if(g_ifMng->m_winControl[i]->BeforeState())
{
g_ifMng->m_winControl[i]->SetBeforeState(false);
g_ifMng->m_winControl[i]->Enable(true);
}
}
g_ifMng->m_observerMenuWin->Enable(false);
g_ifMng->m_observerInfoWin->Enable(false);
g_ifMng->m_tournamentMiniWin->Enable(false);
g_ifMng->m_battleTicketWin->Enable(false);
g_ifMng->m_shareWin->Enable(false);
}
void CGolryunBattle::RecvObserveStart()
{
BOOL bSuccess = MSG_ReadByte();
if(FALSE == bSuccess && FALSE == g_pApp->m_myCharacter->m_bWaitingRoom){
g_pApp->m_bAppExit = TRUE;
PostMessage(g_pApp->m_hWnd,WM_CLOSE,0,0);
return;
}
SetObserverMode(eObserverMode::observe);
g_camera.m_maxCamDist = -700.0f;
memcpy(m_OldPosition, g_pApp->m_myCharacter->position, sizeof(vec3_t));
g_pApp->m_myCharacter->position[0] = 2108;
g_pApp->m_myCharacter->position[1] = -11771;
g_pApp->m_myCharacter->position[2] = -300;
m_ObserverPos[0] = 2108;
m_ObserverPos[1] = -11771;
m_ObserverPos[2] = 180;
g_pApp->m_myCharacter->m_bObserveMode = TRUE;
g_ifMng->m_chatWin->Enable( false );
for( int i = 0; i < NUM_IF_WINDOW_TYPE; i ++ )
{
if(g_ifMng->m_winControl[i]->State())
{
g_ifMng->m_winControl[i]->SetBeforeState(true);
g_ifMng->m_winControl[i]->Enable(false);
}
}
g_ifMng->m_dlgWin->Enable(true);
g_ifMng->m_observerMenuWin->Enable(true);
g_ifMng->m_observerInfoWin->Enable(true);
}
void CGolryunBattle::RecvTwoGyunTotalNak(void)
{
int totalNak = MSG_ReadLong();
char szTemp[256];
sprintf( szTemp, "Total Income Nak: %s", g_ifMng->GetNumberString( totalNak ) );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp);
}
void CGolryunBattle::RecvNoticeBattle(void)
{
char notice[256];
strcpy(notice, MSG_ReadString());
g_ifMng->AddNoticeMessage( notice, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle::RecvStatusMatchNotice(void)
{
int noticeIdx = MSG_ReadShort();
char szTemp[255];
switch(noticeIdx)
{
case 1:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,361) );
break;
case 4:
case 2:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,362) );
break;
case 3:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,363) );
break;
}
g_ifMng->AddSysMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle::RecvSyncRASAMatch(void)
{
g_pApp->m_myCharacter->curRA = MSG_ReadLong();
g_pApp->m_myCharacter->curSA = MSG_ReadShort();
g_pApp->m_myCharacter->calMaxRA = MSG_ReadLong();
g_pApp->m_myCharacter->calMaxSA = MSG_ReadShort();
}
void CGolryunBattle::RecvCheckJoinerNum(void)
{
int joinNum = MSG_ReadShort();
char szTemp[256];
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,364), joinNum);
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp);
}
void CGolryunBattle::RecvStartMatchNotice(void)
{
g_ifMng->m_observerInfoWin->m_redFighterNumber = MSG_ReadShort();
g_ifMng->m_observerInfoWin->m_blueFighterNumber = MSG_ReadShort();
}
void CGolryunBattle::RecvEndMatchNotice(void)
{
if(g_ifMng->m_tournamentWin->State() || g_ifMng->m_tournamentMiniWin->State()){
SendReNewDisplayTournament();
}
if(g_ifMng->m_observerInfoWin->State()){
g_ifMng->m_observerInfoWin->m_RemainTime = 0;
g_ifMng->m_observerInfoWin->m_redFighterNumber = 0;
g_ifMng->m_observerInfoWin->m_blueFighterNumber = 0;
}
}
void CGolryunBattle::RecvReNewBattleTicket(void)
{
if(g_ifMng->m_battleTicketWin->State()){
SendReNewBattleTicket();
}
}
void CGolryunBattle::RecvErrorCode()
{
BYTE eCode = MSG_ReadByte();
BYTE eType = MSG_ReadByte();
char szTemp[256];
int level;
switch(eType)
{
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_1:
level = g_golryunManagerTable[m_iTournamentIdx].levelMin;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,147), level );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_2:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL,36));
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_3:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,366) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_4:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,367) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_5:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,368) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_6:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,369) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_7:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,345) );
break;
case tagGolryun_Packet_Error_Code::GB_ERROR_CODE_8:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL,49));
break;
}
}
void CGolryunBattle::RecvLocalUserNotice()
{
int lpackIdx = MSG_ReadShort();
char szTemp[255];
switch(lpackIdx)
{
case 151:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,151), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 152:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,152), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 158:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,158), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 159:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,159), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 160:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,160), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 161:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,161), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 162:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,162), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 209:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,209), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 210:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,210), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 163:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,163), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 164:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,164), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 166:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,166), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 167:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,167));
break;
case 169:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,169), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
case 370:
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,370), g_golryunManagerTable[m_iTournamentIdx].levelMin );
break;
}
g_ifMng->AddNoticeMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
g_ifMng->AddSysMessage( szTemp, D3DCOLOR_ARGB(255, 55, 255, 55) );
}
void CGolryunBattle::RecvAllUserData()
{
m_iTournamentIdx = MSG_ReadShort();
}
void CGolryunBattle::RecvTransGolryun()
{
m_iTournamentIdx = MSG_ReadShort();
m_iBattleIdx = MSG_ReadShort();
ProcessTransGolryunBattle();
}
void CGolryunBattle::RecvTransArayan()
{
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,373),
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_TRANSPORT_ARAYAN_ACCEPT );
}
void CGolryunBattle::RecvSuggestBattle()
{
char szTemp[256];
int level, deposit;
BYTE eType = MSG_ReadByte();
m_iBattleIdx = MSG_ReadShort();
m_iTournamentIdx = MSG_ReadShort();
switch(eType)
{
case 0:
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,374));
break;
case 1:
level = g_golryunManagerTable[m_iTournamentIdx].levelMin;
deposit = g_golryunManagerTable[m_iTournamentIdx].deposit;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,149), level, deposit );
g_ifMng->SetMessage( g_LPACK.GetMassage( LPACK_TYPE_NORMAL, 322 ), szTemp,
MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_GB_BATTLE_SUGGEST_ACCEPT );
break;
case 2:
level = g_golryunManagerTable[m_iTournamentIdx].levelMin;
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,147), level );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp );
break;
}
g_ifMng->m_chatWin->Enable( false );
}
void CGolryunBattle::RecvOpenBattleTicket()
{
GTH_UnlockSending();
BYTE eType = MSG_ReadByte();
if(eType)
{
m_Tournament->m_iTournamentGUID = MSG_ReadShort();
m_iBattleIdx = MSG_ReadShort();
m_iTournamentIdx = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_JoinerCnt = MSG_ReadShort();
for(int i=0; i<g_ifMng->m_battleTicketWin->m_JoinerCnt; i++)
{
g_ifMng->m_battleTicketWin->m_ticketList[i].num = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].job = MSG_ReadByte();
g_ifMng->m_battleTicketWin->m_ticketList[i].win = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].lose = MSG_ReadShort();
g_ifMng->m_battleTicketWin->m_ticketList[i].shareRate = MSG_ReadFloat();
}
g_ifMng->m_battleTicketWin->m_winNumber = 0;
g_ifMng->m_battleTicketWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_battleTicketWin );
}
else
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,375));
}
g_ifMng->m_chatWin->Enable( false );
}
void CGolryunBattle::RecvBuyBattleTicket()
{
g_cgv.myCharacterInfo->curChargeSE = MSG_ReadLong();
}
void CGolryunBattle::RecvShareRate()
{
for(int i=0; i<g_ifMng->m_battleTicketWin->m_JoinerCnt; i++)
{
g_ifMng->m_battleTicketWin->m_ticketList[i].shareRate = MSG_ReadFloat();
}
}
void CGolryunBattle::RecvOpenShareWin()
{
GTH_UnlockSending();
m_iBattleIdx = MSG_ReadShort();
for(int i=0; i<MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
m_BattleCurrent->Tournament[i].bComplete = MSG_ReadByte();
m_BattleCurrent->Tournament[i].m_iTournamentGUID = MSG_ReadShort();
m_BattleCurrent->Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
m_BattleCurrent->Tournament[i].m_ShareRate = MSG_ReadFloat();
}
int recordIdx=0;
if(m_iBattleIdx>MAX_NUM_BATTLE_RECORD) recordIdx = MAX_NUM_BATTLE_RECORD;
else recordIdx = m_iBattleIdx-1;
for(int idx=0; idx<recordIdx; idx++)
{
for(int i=0; i<MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
m_BattleRecord[idx].m_iBattleGUID = MSG_ReadShort();
m_BattleRecord[idx].Tournament[i].bComplete = MSG_ReadByte();
m_BattleRecord[idx].Tournament[i].m_iTournamentGUID = MSG_ReadShort();
m_BattleRecord[idx].Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
m_BattleRecord[idx].Tournament[i].m_ShareRate = MSG_ReadFloat();
}
}
g_ifMng->m_shareWin->m_iBattleCnt = m_iBattleIdx;
g_ifMng->m_shareWin->InitShareInventory();
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_shareWin->Enable();
g_ifMng->m_itemWin->Enable();
g_ifMng->SetFocus( g_ifMng->m_shareWin );
}
void CGolryunBattle::RecvDisplayTournament()
{
GTH_UnlockSending();
int i,j;
m_iTournamentIdx = MSG_ReadShort();
for(i=0; i<MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
m_BattleCurrent->Tournament[i].bComplete = MSG_ReadByte();
m_BattleCurrent->Tournament[i].FirstWinner.iFightNum = MSG_ReadShort();
}
for (i=0;i<MAX_NUM_MATCH_PER_TOURNAMENT;i++)
{
m_Match[i].bComplete = MSG_ReadByte();
for (j=0;j<2;j++)
{
m_Match[i].Fighter[j].iFightNum = MSG_ReadShort();
m_Match[i].Fighter[j].bWin = MSG_ReadByte();
}
}
m_Tournament->FirstWinner.iFightNum = MSG_ReadShort();
g_ifMng->m_chatWin->Enable( false );
if(g_pApp->m_myCharacter->m_bObserveMode)
{
g_ifMng->m_tournamentMiniWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_tournamentMiniWin );
}
else
{
g_ifMng->m_tournamentWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_tournamentWin );
}
}
void CGolryunBattle::RecvCheckPrize()
{
for(int i=0; i<MAX_NUM_PRIZE_LIST_PER_BATTLE; i++)
{
m_BattleCurrent->m_PrizeNumber[i] = MSG_ReadShort();
}
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_prizeWin->Enable( true );
g_ifMng->SetFocus( g_ifMng->m_prizeWin );
}
void CGolryunBattle::RecvEffectCount()
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->angles[YAW] = MSG_ReadShort();
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_COUNT);
g_input->MouseEnable(false);
g_input->KeyEnable(false);
}
void CGolryunBattle::RecvMatchProgressTime()
{
g_ifMng->m_golryunInfoWin->m_RemainTime = MSG_ReadLong();
}
void CGolryunBattle::RecvStartMatch()
{
g_ifMng->m_golryunInfoWin->m_RemainTime = MSG_ReadLong();
g_ifMng->m_golryunInfoWin->Enable(true);
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_golryunInfoWin );
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_PROGRESS_MATCH);
}
void CGolryunBattle::RecvEndMatch()
{
g_musicMng->ChangeBGMusic( g_pApp->m_mapInfos[ 0 ].BGMusic );
g_ifMng->m_golryunInfoWin->m_RemainTime=0;
g_ifMng->m_golryunInfoWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_END_MATCH);
}
void CGolryunBattle::RecvInitTournament()
{
g_ifMng->m_golryunInfoWin->m_RemainTime=0;
g_ifMng->m_golryunInfoWin->Enable(false);
g_ifMng->m_miniMapWin->Enable(true);
g_pApp->m_myCharacter->m_bWaitingRoom = FALSE;
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT);
}
void CGolryunBattle::RecvJoinNumber()
{
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->m_JoinNum = MSG_ReadShort();
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_BETTING);
}
void CGolryunBattle::RecvEffectResult()
{
int index = MSG_ReadShort();
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
myChar->angles[YAW] = 90;
VectorCopy( g_camera.m_angles, myChar->angles );
g_camera.m_angles[YAW] = myChar->angles[YAW] + 180.0f;
int effIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
index,
myChar->position,
NULL,
true,
myChar->entityType,
myChar->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
switch(index)
{
case 66:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_SUCCESS ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
case 67:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_FAIL ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
case 68:
g_musicMng->PlaySample3D( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_CONG ), GTH_SOUND_PLAY_ONCE , myChar->position );
break;
}
}
void CGolryunBattle::ProcessEffectCount()
{
if(GetStatus() != tagGolryun_Packet_Status::GB_REQUEST_START_COUNT) return;
if(g_camera.m_angles[YAW]++>360) g_camera.m_angles[YAW] = 0;
g_camera.m_distance = -300;
g_camera.m_angles[PITCH] = 30;
m_iUpdateTime = (unsigned int)g_timer.GetAppMilliTime();
DWORD remainTime = m_iUpdateTime-m_iStartTime;
if(remainTime < 1000)
return;
m_iStartTime = m_iUpdateTime;
Fx_CHARACTER_t *myChar = g_pApp->m_myCharacter;
int effIdx = g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
54+m_iStartCnt,
myChar->position,
NULL,
true,
myChar->entityType,
myChar->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
if(m_iStartCnt++>=10)
{
myChar->pvpMode = true;
VectorCopy( g_camera.m_angles, myChar->angles );
g_camera.m_angles[PITCH] = 30;
m_iStartCnt=0;
SetStatus(tagGolryun_Packet_Status::GB_REQUEST_PROGRESS_MATCH);
g_input->MouseEnable(true);
g_input->KeyEnable(true);
if(!g_golryunManagerTable[m_iTournamentIdx].bcontrol)
{
g_ifMng->m_golryunInfoWin->Enable(true);
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_golryunInfoWin );
}
g_musicMng->ChangeBGMusic( "../BGMusic/thefight.mp3" );
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_READYFIGHT ), GTH_SOUND_PLAY_ONCE );
}
else
{
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_COUNT ), GTH_SOUND_PLAY_ONCE );
}
}
void CGolryunBattle::ProcessTransGolryunBattle()
{
if(TRUE == CheckInventoryMaxSize())
{
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL,49));
return;
}
for( int i=0; i<MAX_INVENTORY_SIZE; i++ )
{
if( g_cgv.myCharacterInfo->inventory[i] < 0 ) continue;
int itemIdx = g_cgv.myCharacterInfo->inventory[i];
if(g_cgv.myCharacterInfo->item[itemIdx].itemTableIdx == ENTERANCE_TICKET_ITEM_INDEX &&
g_cgv.myCharacterInfo->item[itemIdx].optionIdx[0] == m_iBattleIdx )
{
GTH_SendMessage_TransportWorld( CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX, 0 );
g_ifMng->m_chatWin->Enable( false );
return;
}
}
g_GolryunBattle_Encoder.SendAcceptTransGolryun();
GTH_SendMessage_TransportWorld( CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX, 0 );
g_ifMng->m_chatWin->Enable( false );
}
void CGolryunBattle::ProcessSuggestBattle()
{
char szTemp[256];
int level = g_cgv.myCharacterInfo->level;
if(g_cgv.myCharacterInfo->curChargeSE < g_golryunManagerTable[m_iTournamentIdx].deposit)
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,150));
return;
}
if(level<g_golryunManagerTable[m_iTournamentIdx].levelMin ||
level>g_golryunManagerTable[m_iTournamentIdx].levelMax)
{
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,145), g_golryunManagerTable[m_iTournamentIdx].levelMin );
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), szTemp);
return;
}
g_pApp->m_myCharacter->m_bWaitingRoom = TRUE;
g_pApp->m_myCharacter->m_JoinNum=0;
g_cgv.myCharacterInfo->curChargeSE -= g_golryunManagerTable[m_iTournamentIdx].deposit;
g_ifMng->AddSysMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,148), D3DCOLOR_ARGB(255, 55, 255, 55) );
g_GolryunBattle_Encoder.SendAcceptToBattle();
g_ifMng->m_chatWin->Enable( false );
if(g_pApp->m_myCharacter->worldIdx != CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX)
GTH_SendMessage_TransportWorld( CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX, 1 );
}
int CGolryunBattle::EncodeSerial(int time, int level, int winNum)
{
TicketSerialInfo ticket;
ticket.TIME=time;
ticket.LEVEL=level;
ticket.WINNUM=winNum;
int Serial;
memcpy(&Serial,&ticket,sizeof(TicketSerialInfo));
return Serial;
}
TicketSerialInfo CGolryunBattle::DecodeSerial(int Serial)
{
TicketSerialInfo ticket;
memcpy(&ticket,&Serial,sizeof(TicketSerialInfo));
return ticket;
}
struct CGolryunBattle::tagMatch*
CGolryunBattle::GetMatchPointer(const int matchIdx)
{
if(matchIdx<0) return NULL;
if(matchIdx>=MAX_NUM_MATCH_PER_TOURNAMENT) return NULL;
return &m_Match[matchIdx];
}
struct CGolryunBattle::tagBattle*
CGolryunBattle::FindBattleRecordPointer(const int battleIdx)
{
struct tagBattle* pRecorder = NULL;
for(int recordIdx=0; recordIdx<MAX_NUM_BATTLE_RECORD; recordIdx++)
{
pRecorder = &m_BattleRecord[recordIdx];
if(pRecorder->m_iBattleGUID == battleIdx) return pRecorder;
}
return NULL;
}
struct CGolryunBattle::tagBattle*
CGolryunBattle::GetBattleRecordPointer(const int battleIdx)
{
if(battleIdx<0) return NULL;
if(battleIdx>=MAX_NUM_BATTLE_RECORD) return NULL;
return &m_BattleRecord[battleIdx];
}
void CGolryunBattle::SetManorGrade(Fx_CHARACTER_t *character )
{
DWORD manorColor[] =
{
D3DCOLOR_ARGB( 255, 255, 255, 255 ),
D3DCOLOR_ARGB( 255, 74, 239, 0 ),
D3DCOLOR_ARGB( 255, 0, 218, 252 ),
D3DCOLOR_ARGB( 255, 2, 84, 254 ),
D3DCOLOR_ARGB( 255, 0, 0, 0 ),
};
int nameColorIdx = character->m_NameColorIdx;
if(character->m_bWaitingRoom)
g_chatManager->SetColor( manorColor[0] );
else
g_chatManager->SetColor( manorColor[nameColorIdx] );
}
BOOL CGolryunBattle::CheckInventoryMaxSize()
{
for( int i=0; i<MAX_INVENTORY_SIZE; i++ )
{
if( g_cgv.myCharacterInfo->inventory[i] < 0 )
{
return FALSE;
}
}
return TRUE;
}
void CGolryunBattle::SetupObserver(void)
{
vec3_t angle;
memset(angle, 0, sizeof(vec3_t));
g_camera.AdjustCameraAngle( m_ObserverPos , angle , g_timer.GetElapsedTime() );
g_camera.AdjustCamera( m_ObserverPos , angle );
if ( g_charManager ->m_tbDo )
{
vec3_t trembleDelta;
trembleDelta [0] = sin ( g_timer .GetAppTime () * 70.0f ) * 5.0f * g_charManager ->m_tbPower;
trembleDelta [1] = cos ( g_timer .GetAppTime () * 68.0f ) * 5.0f * g_charManager ->m_tbPower;
trembleDelta [2] = sin ( g_timer .GetAppTime () * 66.0f ) * cos ( g_timer .GetAppTime () * 64.0f ) * 5.0f * g_charManager ->m_tbPower;
VectorAdd ( g_camera.m_position, g_camera.m_position, trembleDelta );
}
g_camera.SetupMatrices( true );
}
void CGolryunBattle::SetupReStartGame()
{
SetObserverMode(eObserverMode::general);
g_pApp->m_myCharacter->m_bObserveMode = FALSE;
g_pApp->m_myCharacter->m_bWaitingRoom = FALSE;
g_pApp->m_myCharacter->m_JoinNum = 0;
g_camera.m_maxCamDist = -350.0f;
g_camera.m_distance = -350.0f;
}
| C++ |
#ifndef _GOLRYUNBATTLE_DECODER_H_
#define _GOLRYUNBATTLE_DECODER_H_
#include "../game/GolryunBattle/GolryunBattle.h"
#include "../game/GolryunBattle/GolryunBattle_Encoder.h"
class CGolryunBattle_Decoder
{
private:
public :
CGolryunBattle_Decoder();
virtual ~CGolryunBattle_Decoder();
public :
void RecvGolryunBattle();
void RecvTransGolryun();
void RecvTransArayan();
void RecvSuggestBattle();
void RecvActiveBattle();
void RecvOpenBattleTicket();
void RecvShareRate();
void RecvReNewBattleTicket(void);
void RecvOpenShareWin();
void RecvDisplayTournament();
void RecvCheckPrize();
void RecvEffectCount();
void RecvEffectResult();
void RecvStartMatch();
void RecvEndMatch();
void RecvCancelTournament();
void RecvErrorCode();
void RecvJoinNumber();
void RecvLocalUserNotice();
void RecvAllUserData();
void RecvStartMatchNotice(void);
void RecvEndMatchNotice(void);
void RecvSyncRASAMatch(void);
void RecvCheckJoinerNum(void);
void RecvStatusMatchNotice(void);
void RecvNoticeBattle(void);
void RecvBuyBattleTicket(void);
void RecvTwoGyunTotalNak(void);
void RecvObserveStart(void);
void RecvObserveEnd(void);
void RecvObserveMatchTime(void);
void RecvMatchProgressTime(void);
void RecvMessageToGM(void);
};
extern CGolryunBattle_Decoder g_GolryunBattle_Decoder;
#endif | C++ |
#include "../global_def.h"
#include "../game/GolryunBattle/GolryunBattle_Command.h"
#include "../game/GolryunBattle/GolryunBattle_Encoder.h"
CGolryunBattle_Command g_GolryunBattle_Command;
CGolryunBattle_Command::CGolryunBattle_Command()
{
}
CGolryunBattle_Command::~CGolryunBattle_Command()
{
}
void CGolryunBattle_Command::ProcessCommandToGM(char message[], char command[], chatMessage param[])
{
CommandToGMBattleNotice(message, command, param);
CommandToGMBattleStart(message, command, param);
CommandToGMJoinStart(message, command, param);
CommandToGMRecallStart(message, command, param);
CommandToGMJoinClose(message, command, param);
CommandToGMBettingStart(message, command, param);
CommandToGMReadyTournament(message, command, param);
CommandToGMStartTournament(message, command, param);
CommandToGMPauseTournament(message, command, param);
CommandToGMReStartTournament(message, command, param);
CommandToGMCloseBattle(message, command, param);
CommandToGMTransportGolryun(message, command, param);
CommandToGMTransportWaitingRoom(message, command, param);
CommandToGMTransportBattleField(message, command, param);
CommandToGMWalkOverMatch(message, command, param);
CommandToGMCheckJoinNumber(message, command, param);
CommandToGMStartDrawPrize(message, command, param);
CommandToGMCancelTournament(message, command, param);
CommandToGMTaltalNakBetting(message, command, param);
CommandToGMForceJoinList(message, command, param);
CommandToGMAssignFighterNumber(message, command, param);
CommandToGMForceEject(message, command, param);
CommandToGMCheckStatusPvPMode(message, command, param);
}
void CGolryunBattle_Command::CommandToGMBattleNotice(char message[], char command[], chatMessage param[])
{
if ( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 376)) )
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if(NULL == param[0][0]) return;
g_GolryunBattle_Encoder.SendNoticeBattle(param[0]);
}
}
void CGolryunBattle_Command::CommandToGMBattleStart(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 201)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
int intparam = atoi( param[0] );
switch(intparam)
{
case CGolryunBattle::eManor::normal:
break;
case CGolryunBattle::eManor::week:
break;
case CGolryunBattle::eManor::month:
break;
case CGolryunBattle::eManor::ramification:
break;
case CGolryunBattle::eManor::year:
break;
default:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 379));
return;
}
char szTemp[255];
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,205));
g_GolryunBattle_Encoder.SendRequestStartBattle(intparam);
GTH_SendMessage_SystemAdimin_Notice( szTemp );
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
}
}
void CGolryunBattle_Command::CommandToGMJoinStart(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 206)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
int intparam = atoi( param[0] );
switch(intparam)
{
case 30:
g_GolryunBattle.SetTournamentIdx(0);
break;
case 40:
g_GolryunBattle.SetTournamentIdx(1);
break;
case 50:
g_GolryunBattle.SetTournamentIdx(2);
break;
case 60:
g_GolryunBattle.SetTournamentIdx(3);
break;
case 70:
g_GolryunBattle.SetTournamentIdx(4);
break;
case 80:
g_GolryunBattle.SetTournamentIdx(5);
break;
case 90:
g_GolryunBattle.SetTournamentIdx(6);
break;
default:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 379) );
return;
}
char szTemp[255];
int cnt = g_GolryunBattle.GetTournamentIdx();
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,143), g_golryunManagerTable[cnt].levelMin);
g_GolryunBattle_Encoder.SendRequestStartJoin(szTemp);
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_JOIN);
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
}
}
void CGolryunBattle_Command::CommandToGMRecallStart(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 463)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
int intparam = atoi( param[0] );
switch(intparam)
{
case 30:
g_GolryunBattle.SetTournamentIdx(0);
break;
case 40:
g_GolryunBattle.SetTournamentIdx(1);
break;
case 50:
g_GolryunBattle.SetTournamentIdx(2);
break;
case 60:
g_GolryunBattle.SetTournamentIdx(3);
break;
case 70:
g_GolryunBattle.SetTournamentIdx(4);
break;
case 80:
g_GolryunBattle.SetTournamentIdx(5);
break;
case 90:
g_GolryunBattle.SetTournamentIdx(6);
break;
default:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 379) );
return;
}
char szTemp[255];
int cnt = g_GolryunBattle.GetTournamentIdx();
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,464), g_golryunManagerTable[cnt].levelMin);
g_GolryunBattle_Encoder.SendRequestStartReCallFighter(szTemp);
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
}
}
void CGolryunBattle_Command::CommandToGMJoinClose(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 422)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestCloseJoin();
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_CLOSE_JOIN);
}
}
void CGolryunBattle_Command::CommandToGMBettingStart(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 202)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestStartBetting();
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_START_BETTING);
}
}
void CGolryunBattle_Command::CommandToGMReadyTournament(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 203)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
int intparam = atoi( param[0] );
switch(intparam)
{
case CGolryunBattle::eRoundStep::round_16:
break;
case CGolryunBattle::eRoundStep::round_8:
break;
case CGolryunBattle::eRoundStep::round_4:
break;
case CGolryunBattle::eRoundStep::round_final:
break;
default:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 379) );
return;
}
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestReadyTournament(intparam);
g_GolryunBattle.SetStatus(tagGolryun_Packet_Status::GB_REQUEST_READY_TOURNAMENT);
}
}
void CGolryunBattle_Command::CommandToGMStartTournament(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 204)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestStartCount();
}
}
void CGolryunBattle_Command::CommandToGMPauseTournament(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 207)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestPauseMatch();
}
}
void CGolryunBattle_Command::CommandToGMReStartTournament(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 467)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestReStartMatch();
}
}
void CGolryunBattle_Command::CommandToGMCloseBattle(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 208)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
char szTemp[255];
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,169));
g_GolryunBattle_Encoder.SendRequestCloseBattle();
GTH_SendMessage_SystemAdimin_Notice( szTemp );
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
}
}
void CGolryunBattle_Command::CommandToGMTransportGolryun(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 176)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if(g_pApp->m_myCharacter->worldIdx == CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX )
g_GolryunBattle_Encoder.SendTransWatchingRoom();
else
GTH_SendMessage_TransportWorld( CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX, 0 );
}
}
void CGolryunBattle_Command::CommandToGMTransportWaitingRoom(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 377)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if(g_pApp->m_myCharacter->worldIdx == CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX )
g_GolryunBattle_Encoder.SendTransWaitingRoom();
else
GTH_SendMessage_TransportWorld( CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX, 1 );
}
}
void CGolryunBattle_Command::CommandToGMTransportBattleField(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 378)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if(g_pApp->m_myCharacter->worldIdx == CGolryunBattle::GOLRYUN_BATTLE_MAP_INDEX )
g_GolryunBattle_Encoder.SendTransBattleStadium();
else
return;
}
}
void CGolryunBattle_Command::CommandToGMWalkOverMatch(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 381)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
int intparam = atoi( param[0] );
if(intparam<0 || intparam > CGolryunBattle::MAX_NUM_FIGHTER_PER_TOURNAMENT)
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 379) );
return;
}
g_GolryunBattle_Encoder.SendWalkOverMatch(intparam);
}
}
void CGolryunBattle_Command::CommandToGMCheckJoinNumber(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 382)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendCheckJoinerNum();
}
}
void CGolryunBattle_Command::CommandToGMStartDrawPrize(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 383)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
char szTemp[255];
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,172));
g_GolryunBattle_Encoder.SendRequestStartPrize();
GTH_SendMessage_SystemAdimin_Notice( szTemp );
}
}
void CGolryunBattle_Command::CommandToGMCancelTournament(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 384)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendRequestCancelTournament();
}
}
void CGolryunBattle_Command::CommandToGMTaltalNakBetting(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 421)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendTwoGyunTotalNak();
}
}
void CGolryunBattle_Command::CommandToGMForceJoinList(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 465)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if( param[0][0] == 0 ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendInsertJoinList(param[0]);
}
}
void CGolryunBattle_Command::CommandToGMAssignFighterNumber(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 466)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if( param[0][0] == 0 ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendAssignFighterNumber( param[0], atoi(param[1]) );
}
}
void CGolryunBattle_Command::CommandToGMForceEject(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 539)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
if( param[0][0] == 0 ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendForceEject( param[0]);
}
}
void CGolryunBattle_Command::CommandToGMCheckStatusPvPMode(char message[], char command[], chatMessage param[])
{
if( !stricmp( command, g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 540)))
{
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return;
g_ifMng->AddChatMessage( message, GTHCOLOR_SYSMESSAGE,
g_pApp->m_myCharacter->name, IF_CHATMSG_TYPE_SYSTEM );
g_GolryunBattle_Encoder.SendCheckStatusPvPMode();
}
}
| C++ |
#ifndef _GOLRYUNBATTLE_COMMAND_H_
#define _GOLRYUNBATTLE_COMMAND_H_
#include "../game/GolryunBattle/GolryunBattle.h"
#include "../game/GolryunBattle/GolryunBattle_Encoder.h"
class CGolryunBattle_Command
{
private:
public :
CGolryunBattle_Command();
virtual ~CGolryunBattle_Command();
public :
void ProcessCommandToGM(char message[], char command[], chatMessage param[]);
void CommandToGMBattleNotice(char message[], char command[], chatMessage param[]);
void CommandToGMBattleStart(char message[], char command[], chatMessage param[]);
void CommandToGMJoinStart(char message[], char command[], chatMessage param[]);
void CommandToGMRecallStart(char message[], char command[], chatMessage param[]);
void CommandToGMJoinClose(char message[], char command[], chatMessage param[]);
void CommandToGMBettingStart(char message[], char command[], chatMessage param[]);
void CommandToGMReadyTournament(char message[], char command[], chatMessage param[]);
void CommandToGMStartTournament(char message[], char command[], chatMessage param[]);
void CommandToGMPauseTournament(char message[], char command[], chatMessage param[]);
void CommandToGMReStartTournament(char message[], char command[], chatMessage param[]);
void CommandToGMCloseBattle(char message[], char command[], chatMessage param[]);
void CommandToGMTransportGolryun(char message[], char command[], chatMessage param[]);
void CommandToGMTransportWaitingRoom(char message[], char command[], chatMessage param[]);
void CommandToGMTransportBattleField(char message[], char command[], chatMessage param[]);
void CommandToGMWalkOverMatch(char message[], char command[], chatMessage param[]);
void CommandToGMCheckJoinNumber(char message[], char command[], chatMessage param[]);
void CommandToGMStartDrawPrize(char message[], char command[], chatMessage param[]);
void CommandToGMCancelTournament(char message[], char command[], chatMessage param[]);
void CommandToGMTaltalNakBetting(char message[], char command[], chatMessage param[]);
void CommandToGMForceJoinList(char message[], char command[], chatMessage param[]);
void CommandToGMAssignFighterNumber(char message[], char command[], chatMessage param[]);
void CommandToGMForceEject(char message[], char command[], chatMessage param[]);
void CommandToGMCheckStatusPvPMode(char message[], char command[], chatMessage param[]);
};
extern CGolryunBattle_Command g_GolryunBattle_Command;
#endif | C++ |
#ifndef _GOLRYUNBATTLE_ENCODER_H_
#define _GOLRYUNBATTLE_ENCODER_H_
class CGolryunBattle_Encoder
{
public :
private :
public :
CGolryunBattle_Encoder();
virtual ~CGolryunBattle_Encoder();
public :
void SendRequestStartBattle(int iManorIdx);
void SendRequestStartJoin(char* message);
void SendRequestCloseJoin();
void SendRequestStartBetting();
void SendRequestReadyTournament(int iRound);
void SendRequestStartCount();
void SendRequestEndMatch();
void SendRequestWaitTournament();
void SendRequestCloseBattle();
void SendRequestStartPrize();
void SendRequestCancelTournament();
void SendAcceptTransGolryun();
void SendAcceptToBattle();
void SendBuyBattleTicket(int itemTableIdx, int number);
void SendReNewBattleTicket();
void SendReNewDisplayTournament();
void SendCheckStartMatch();
void SendCheckJoinerNum();
void SendTransWaitingRoom();
void SendTransWatchingRoom();
void SendTransBattleStadium();
void SendNoticeBattle(char* notice);
void SendWalkOverMatch(int joinNum);
void SendTwoGyunTotalNak(void);
void SendObserveEnd(void);
void SendOpenBattleTicket(void);
void SendOpenShareWin(void);
void SendDisplayTournament(void);
void SendRequestPauseMatch(void);
void SendRequestReStartMatch(void);
void SendInsertJoinList(char* name);
void SendAssignFighterNumber(char* name, int number);
void SendRequestStartReCallFighter(char* message);
void SendForceEject(char* name);
void SendCheckStatusPvPMode(void);
};
extern CGolryunBattle_Encoder g_GolryunBattle_Encoder;
#endif | C++ |
#include "../global_def.h"
#include "../game/GolryunBattle/GolryunBattle.h"
#include "../game/GolryunBattle/GolryunBattle_Encoder.h"
CGolryunBattle_Encoder g_GolryunBattle_Encoder;
CGolryunBattle_Encoder::CGolryunBattle_Encoder()
{
}
CGolryunBattle_Encoder::~CGolryunBattle_Encoder()
{
}
void CGolryunBattle_Encoder::SendRequestStartBattle(int iManorIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_BATTLE);
MSG_WriteShort(&netMessage, iManorIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestStartJoin(char* message)
{
int iTournamentIdx = g_GolryunBattle.GetTournamentIdx();
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_JOIN);
MSG_WriteShort(&netMessage, iTournamentIdx);
MSG_WriteString(&netMessage, message);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestCloseJoin()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CLOSE_JOIN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestStartBetting()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_BETTING);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestReadyTournament(int iRound)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_READY_TOURNAMENT);
MSG_WriteShort(&netMessage, iRound );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestStartCount()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_COUNT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestPauseMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_PAUSE_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestReStartMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RESTART_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestEndMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_END_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestWaitTournament()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_WAIT_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestCloseBattle()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CLOSE_BATTLE);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestStartPrize()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_START_PRIZE);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendTransWatchingRoom()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_WATCHINGROOM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendTransWaitingRoom()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_WAITINGROOM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendTransBattleStadium()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TRANS_BATTLESTADIUM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendNoticeBattle(char* notice)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_NOTICE_BATTLE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendWalkOverMatch(int joinNum)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_WALKOVER_MATCH);
MSG_WriteShort(&netMessage, joinNum);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendCheckJoinerNum()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_CHECK_JOINER_NUM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestCancelTournament()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_REQUEST_CANCEL_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendTwoGyunTotalNak()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_TWOGYUN_TOTAL_NAK);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendAcceptTransGolryun()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ACCEPT_TRANS_GOLRYUN );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendAcceptToBattle()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ACCEPT_BATTLE );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendBuyBattleTicket(int itemTableIdx, int number)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_BUY_BATTLE_TICKET );
MSG_WriteShort(&netMessage, itemTableIdx );
MSG_WriteShort(&netMessage, number );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendReNewBattleTicket()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RENEW_BATTLE_TICKET );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendReNewDisplayTournament()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_RENEW_DISPLAY_TOURNAMENT );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendCheckStartMatch()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_CHECK_START_MATCH);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendObserveEnd()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OBSERVE_END);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendOpenBattleTicket()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OPEN_BATTLE_TICKET);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendOpenShareWin()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_OPEN_SHARE_WIN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendDisplayTournament()
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_DISPLAY_TOURNAMENT);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendInsertJoinList(char* name)
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_INSERT_JOIN_LIST);
MSG_WriteString(&netMessage, name);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendAssignFighterNumber(char* name, int number)
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_ASSIGN_FIGHTER_NUMBER);
MSG_WriteString(&netMessage, name );
MSG_WriteLong(&netMessage, number );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendRequestStartReCallFighter(char* message)
{
if( !GTH_LockSending() ) return;
int iTournamentIdx = g_GolryunBattle.GetTournamentIdx();
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_START_RECALL_FIGHTER);
MSG_WriteShort(&netMessage, iTournamentIdx);
MSG_WriteString(&netMessage, message);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendForceEject(char* name)
{
if( !GTH_LockSending() ) return;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_FORCE_EJECT);
MSG_WriteString(&netMessage, name);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CGolryunBattle_Encoder::SendCheckStatusPvPMode()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_GB_BATTLE );
MSG_WriteByte(&netMessage, tagGolryun_Packet_Status::GB_CHECK_STATUS_PvPMODE);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
| C++ |
#ifndef _IFGOLRYUNBATTLE_H_
#define _IFGOLRYUNBATTLE_H_
#if _MSC_VER > 1000
#pragma once
#endif
#define TICKET_LIST_MAX_NUM 16
#define TICKET_LIST_LINE_HEIGHT 18
struct BattleTicketList
{
int num;
byte job;
int win;
int lose;
float shareRate;
bool checkFlag;
};
class CIFBattleTicketWin : public CIFWindow
{
public:
enum
{
IT_TICKET_TITLE,
IT_TICKET_LIST_NUMBER,
IT_TICKET_LIST_CLASS,
IT_TICKET_LIST_WAR_RECORD,
IT_TICKET_LIST_SHARE_RATE,
NUM_IT_TICKET,
};
public:
CIFText *m_textCtl[NUM_IT_TICKET];
CIFCheckBox *m_checkBtn[TICKET_LIST_MAX_NUM];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFControl *m_selectBar;
CIFButtonCtl *m_exitBtn;
CIFButtonCtl *m_oneWinBtn;
CIFButtonCtl *m_twoWinBtn;
CIFButtonCtl *m_oneTwoWinBtn;
CIFButtonCtl *m_renewBtn;
CIFButtonCtl *m_buy100Btn;
CIFButtonCtl *m_buy10Btn;
CIFButtonCtl *m_cancelBtn;
CIFScrollBar *m_scrollBar;
BattleTicketList m_ticketList[TICKET_LIST_MAX_NUM];
int m_interfaceType;
int m_winNumber;
int m_JoinerCnt;
int m_selectedIdx[2];
int m_selectBarSavePos[2];
bool m_bDisplay;
CIFBattleTicketWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFBattleTicketWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void UpdateTicketList();
int GetTicketCount();
void SetDisplayMode( bool mode );
void SetSelectBar( int idx );
};
class CIFShareWin : public CIFWindow
{
public:
enum
{
IT_SHARE_TITLE,
IT_SHARE_WIN_SERIAL_BAR,
IT_SHARE_WIN_GUID_BAR,
IT_SHARE_WIN_RATE_BAR,
IT_SHARE_WIN_LEVEL,
IT_SHARE_WIN_INVEN_POS,
IT_SHARE_WIN_NAK,
IT_SHARE_WIN_NAK_BAR,
NUM_IT_SHARE,
};
public:
CIFText *m_textCtl[NUM_IT_SHARE];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFButtonCtl *m_battlePrevBtn;
CIFButtonCtl *m_battleNextBtn;
CIFButtonCtl *m_levelPrevBtn;
CIFButtonCtl *m_levelNextBtn;
CIFButtonCtl *m_changeBtn;
CIFButtonCtl *m_cancelBtn;
bool m_bDisplay;
int m_iShareNak;
int m_iBattleCnt;
int m_iLevelCnt;
CIFShareWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFShareWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void CurrentBattleInformation();
void RecordBattleInformation(int battleCnt);
void InitShareInventory();
void UndoShareInventory();
};
struct TournamentInfo
{
int number;
int winNumer;
int stackNum;
float shareRate;
int winMoney;
bool checkFlag;
};
class CIFTournamentWin : public CIFWindow
{
public:
enum
{
IT_TOURNAMENT_TITLE,
IT_TOURNAMENT_STEP0_NUMBER,
IT_TOURNAMENT_STEP1_NUMBER,
IT_TOURNAMENT_STEP2_NUMBER,
IT_TOURNAMENT_STEP3_NUMBER,
IT_TOURNAMENT_STEP4_NUMBER,
IT_TOURNAMENT_WIN_NUMBER,
NUM_IT_TOURNAMENT,
};
public:
CIFText *m_textCtl[NUM_IT_TOURNAMENT];
CIFControl *m_loseX[30];
CIFButtonCtl *m_closeBtn;
CIFTournamentWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFTournamentWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void UpdateTournamentList();
void SetDisplayMode( bool mode );
void SetSelectBar( int idx );
};
struct PrizeInfo
{
int number;
int winNumer;
int stackNum;
float shareRate;
int winMoney;
bool checkFlag;
};
class CIFPrizeWin : public CIFWindow
{
public:
enum
{
IT_PRIZE_GRADE,
IT_PRIZE_ITEM_IMAGE,
IT_PRIZE_STACK_NUM,
IT_PRIZE_ITEM_NAME,
IT_PRIZE_GRADE_POS,
IT_PRIZE_ITEM_IMAGE_POS,
IT_PRIZE_STACK_NUM_POS,
IT_PRIZE_ITEM_NAME_POS,
IT_PRIZE_USER_NAME,
IT_PRIZE_USER_NAME_POS,
NUM_IT_PRIZE,
};
public:
CIFText *m_textCtl[NUM_IT_PRIZE];
CIFButtonCtl *m_closeBtn;
CIFScrollBar *m_scrollBar;
CIFPrizeWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFPrizeWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void UpdatePrizeList();
void UpdatePrizeUserList();
void SetSelectBar( int idx );
};
class CIFGolryunInfoWin : public CIFWindow
{
public:
CIFText *m_textCtl;
CIFControl *m_title;
int m_RemainTime;
bool m_bTimeOver;
CIFGolryunInfoWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFGolryunInfoWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
class CIFObserverMenuWin : public CIFWindow
{
public:
CIFObserverMenuWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFObserverMenuWin();
CIFButtonCtl *m_twogyunBtn;
CIFButtonCtl *m_shareBtn;
CIFButtonCtl *m_seedtableBtn;
CIFButtonCtl *m_closeBtn;
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
class CIFObserverInfoWin : public CIFWindow
{
public:
enum
{
IT_BATTLE_TIME,
IT_RED_FIGHTER_NAME,
IT_BLUE_FIGHTER_NAME,
NUM_IT_OBSERVER_INFO,
};
public:
CIFObserverInfoWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFObserverInfoWin();
CIFText *m_textCtl[NUM_IT_OBSERVER_INFO];
CIFBarCtl *m_redFighterRaBar;
CIFBarCtl *m_redFighterSaBar;
CIFBarCtl *m_blueFighterRaBar;
CIFBarCtl *m_blueFighterSaBar;
int m_RemainTime;
int m_redFighterNumber;
int m_blueFighterNumber;
int m_redFighterCurRa;
int m_redFighterMaxRa;
int m_redFighterCurSa;
int m_redFighterMaxSa;
int m_blueFighterCurRa;
int m_blueFighterMaxRa;
int m_blueFighterCurSa;
int m_blueFighterMaxSa;
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
};
#define TOURNAMENT_NUMBER_MAX_NUM 31
#define LOSE_DISPLAY_MAX_NUM 30
class CIFTournamentMiniWin : public CIFWindow
{
public:
enum
{
IT_TOURNAMENT_MINI_TITLE,
IT_TOURNAMENT_MINI_WIN_NUMBER,
NUM_IT_TOURNAMENT_MINI,
};
public:
CIFText *m_textCtl[NUM_IT_TOURNAMENT_MINI];
CIFText *m_textNumCtl[TOURNAMENT_NUMBER_MAX_NUM];
CIFControl *m_loseX[LOSE_DISPLAY_MAX_NUM];
CIFButtonCtl *m_closeBtn;
CIFTournamentMiniWin( CIFControlNode *pParentControl = NULL );
virtual ~CIFTournamentMiniWin();
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void UpdateTournamentList();
};
#endif
| C++ |
#include "../global_def.h"
#include "IFGolryunBattle.h"
#include "../game/GolryunBattle/GolryunBattle.h"
#include "../game/GolryunBattle/GolryunBattle_Encoder.h"
CIFBattleTicketWin::CIFBattleTicketWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
int i;
for( i=0; i<NUM_IT_TICKET; i++ )
m_textCtl[i] = new CIFText( this );
for( i=0; i<TICKET_LIST_MAX_NUM; i++ )
m_checkBtn[i] = new CIFCheckBox( this );
m_titleBar = new CIFControl( this );
m_titleBarBottom = new CIFControl( this );
m_selectBar = new CIFControl( this );
m_oneWinBtn = new CIFButtonCtl( this );
m_twoWinBtn = new CIFButtonCtl( this );
m_oneTwoWinBtn = new CIFButtonCtl( this );
m_renewBtn = new CIFButtonCtl( this );
m_buy100Btn = new CIFButtonCtl( this );
m_buy10Btn = new CIFButtonCtl( this );
m_cancelBtn = new CIFButtonCtl( this );
m_exitBtn = new CIFButtonCtl( this );
m_scrollBar = new CIFScrollBar( this );
m_interfaceType = MAIL_INTERFACE_TYPE_RECVMAIL;
m_bDisplay = false;
m_winNumber = 0;
m_JoinerCnt = 0;
for( i=0; i<2; i++)
{
m_selectedIdx[i] = -1;
m_selectBarSavePos[i] = 0;
}
for( i=0; i<TICKET_LIST_MAX_NUM; i++)
{
m_ticketList[i].num = i+1;
m_ticketList[i].job = 0;
m_ticketList[i].win = 0;
m_ticketList[i].lose = 0;
m_ticketList[i].shareRate = 1.1f;
m_ticketList[i].checkFlag = false;
}
m_renewBtn->Enable(false);
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_BATTLE_TICKET_WINDOW_TYPE );
}
CIFBattleTicketWin::~CIFBattleTicketWin()
{
}
void CIFBattleTicketWin::PrepareControl()
{
CIFControl::PrepareControl( IF_TICKET_WIN );
m_textCtl[IT_TICKET_TITLE]->PrepareControl( IF_TICKET_TITLE_TEXT );
m_textCtl[IT_TICKET_LIST_NUMBER]->PrepareControl( IF_TICKET_LIST_NUMBER_TEXT );
m_textCtl[IT_TICKET_LIST_CLASS]->PrepareControl( IF_TICKET_LIST_CLASS_TEXT );
m_textCtl[IT_TICKET_LIST_WAR_RECORD]->PrepareControl( IF_TICKET_LIST_WAR_RECORD_TEXT );
m_textCtl[IT_TICKET_LIST_SHARE_RATE]->PrepareControl( IF_TICKET_LIST_SHARE_RATE_TEXT );
m_titleBar->PrepareControl( IF_TICKET_TITLE_BAR );
m_titleBarBottom->PrepareControl( IF_TICKET_TITLE_BAR_BOTTOM );
m_selectBar->PrepareControl( IF_TICKET_SELECT_BAR );
m_oneWinBtn->PrepareControl( IF_TICKET_ONEWIN_BTN_0 );
m_oneTwoWinBtn->PrepareControl( IF_TICKET_ONETWOWIN_BTN_0 );
m_twoWinBtn->PrepareControl( IF_TICKET_TWOWIN_BTN_0 );
m_renewBtn->PrepareControl( IF_TICKET_RENEW_BTN_0 );
m_buy100Btn->PrepareControl( IF_TICKET_BUY100_BTN_0 );
m_buy10Btn->PrepareControl( IF_TICKET_BUY10_BTN_0 );
m_cancelBtn->PrepareControl( IF_TICKET_CANCEL_BTN_0 );
m_exitBtn->PrepareControl( IF_TICKET_EXIT_BTN_0 );
m_scrollBar->PrepareControl( IF_TICKET_SCROLL );
m_scrollBar->SetBarPosition( 0, 0 );
for( int i=0; i<TICKET_LIST_MAX_NUM; i++ )
{
m_checkBtn[i]->PrepareControl( IF_TICKET_CHECKBOX_BTN_0 + i*2, 0.0f, (float)( TICKET_LIST_LINE_HEIGHT * i ) );
m_checkBtn[i]->SetCheck( false );
}
m_selectBarSavePos[0] = g_ifMng->m_iPos[IF_TICKET_SELECT_BAR].clientY;
m_selectBarSavePos[1] = g_ifMng->m_iPos[IF_TICKET_SELECT_BAR].clientY;
}
int CIFBattleTicketWin::WindowFrame()
{
int i;
for( i=0; i<m_JoinerCnt; i++ )
{
if( m_checkBtn[i]->GetCheck() ) break;
}
m_textCtl[IT_TICKET_TITLE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,338) );
m_textCtl[IT_TICKET_LIST_NUMBER]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,339) );
m_textCtl[IT_TICKET_LIST_CLASS]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,340) );
m_textCtl[IT_TICKET_LIST_WAR_RECORD]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,341) );
m_textCtl[IT_TICKET_LIST_SHARE_RATE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,188) );
m_oneWinBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,333) );
m_oneTwoWinBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,334) );
m_oneTwoWinBtn->SetButtonState( IF_BTN_TYPE_DISABLE );
m_twoWinBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,335) );
m_twoWinBtn->SetButtonState( IF_BTN_TYPE_DISABLE );
m_renewBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,342) );
m_buy100Btn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,343) );
m_buy10Btn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,344) );
m_cancelBtn->SetButtonText( g_LPACK.GetMessage(0,521) );
return( IF_CTL_NONE );
}
void CIFBattleTicketWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_titleBar->Render();
m_titleBarBottom->Render();
for( int i=0; i<m_JoinerCnt; i++ )
{
m_checkBtn[i]->Render();
}
m_oneWinBtn->RenderTextBtn();
m_twoWinBtn->RenderTextBtn();
m_oneTwoWinBtn->RenderTextBtn();
m_renewBtn->RenderTextBtn();
m_buy100Btn->RenderTextBtn();
m_buy10Btn->RenderTextBtn();
m_cancelBtn->RenderTextBtn();
m_exitBtn->Render();
m_scrollBar->Render();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_TICKET_TITLE]->Render();
m_textCtl[IT_TICKET_LIST_NUMBER]->Render();
m_textCtl[IT_TICKET_LIST_CLASS]->Render();
m_textCtl[IT_TICKET_LIST_WAR_RECORD]->Render();
m_textCtl[IT_TICKET_LIST_SHARE_RATE]->Render();
UpdateTicketList();
}
g_chatManager->EndFrame();
}
int CIFBattleTicketWin::WindowSelection()
{
int ret;
ret = m_titleBar->Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFBattleTicketWin::WindowProcess()
{
if( m_exitBtn->ProcessButton() == IF_CTL_SELECT )
{
for( int i=0; i<m_JoinerCnt; i++ )
m_checkBtn[i]->SetCheck( false );
Enable( false );
return IF_CTL_SELECT;
}
if( m_oneWinBtn->ProcessButton() == IF_CTL_SELECT )
{
return IF_CTL_SELECT;
}
if( m_oneTwoWinBtn->ProcessButton() == IF_CTL_SELECT )
{
return IF_CTL_SELECT;
}
if( m_twoWinBtn->ProcessButton() == IF_CTL_SELECT )
{
return IF_CTL_SELECT;
}
if( m_renewBtn->ProcessButton() == IF_CTL_SELECT )
{
g_GolryunBattle_Encoder.SendReNewBattleTicket();
return IF_CTL_SELECT;
}
if( m_buy100Btn->ProcessButton() == IF_CTL_SELECT )
{
int ticketCnt = GetTicketCount();
if(ticketCnt>(g_cgv.myCharacterInfo->level/2))
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,346) );
return IF_CTL_SELECT;
}
g_GolryunBattle_Encoder.SendBuyBattleTicket(CGolryunBattle::TWOGYUN_1000000_ITEM_INDEX, m_winNumber);
return IF_CTL_SELECT;
}
if( m_buy10Btn->ProcessButton() == IF_CTL_SELECT )
{
int ticketCnt = GetTicketCount();
if(ticketCnt>(g_cgv.myCharacterInfo->level/2))
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,346) );
return IF_CTL_SELECT;
}
g_GolryunBattle_Encoder.SendBuyBattleTicket(CGolryunBattle::TWOGYUN_100000_ITEM_INDEX, m_winNumber);
return IF_CTL_SELECT;
}
if( m_cancelBtn->ProcessButton() == IF_CTL_SELECT )
{
for( int i=0; i<m_JoinerCnt; i++ )
m_checkBtn[i]->SetCheck( false );
Enable( false );
return IF_CTL_SELECT;
}
if( m_scrollBar->ProcessScrollBar() == IF_CTL_SELECT )
{
return IF_CTL_SELECT;
}
for( int i=0; i<m_JoinerCnt ; i++ )
{
if( m_checkBtn[i]->ProcessCheckBox() == IF_CTL_SELECT )
{
for( int j=0; j<m_JoinerCnt; j++ )
{
m_ticketList[j].checkFlag = false;
m_checkBtn[j]->SetCheck( false );
}
m_winNumber = i+1;
m_checkBtn[i]->SetCheck( true );
m_ticketList[i].checkFlag = m_checkBtn[i]->GetCheck();
return IF_CTL_SELECT;
}
}
return IF_CTL_NONE;
}
int CIFBattleTicketWin::GetTicketCount()
{
CGolryunBattle::tagTournament* pTournament = g_GolryunBattle.GetTournamentPointer();
int invCnt=0;
for( int i=0; i<MAX_INVENTORY_SIZE; i++ )
{
if( g_cgv.myCharacterInfo->inventory[i] < 0 ) continue;
int itemIdx = g_cgv.myCharacterInfo->inventory[i];
int tableIdx = g_cgv.myCharacterInfo->item[itemIdx].itemTableIdx;
int battlIdx = g_cgv.myCharacterInfo->item[itemIdx].optionIdx[0];
int level = g_cgv.myCharacterInfo->item[itemIdx].optionIdx[1];
int serial = g_cgv.myCharacterInfo->item[itemIdx].experience;
int curBattleIdx = g_GolryunBattle.GetBattleIdx();
int cnt = g_GolryunBattle.GetTournamentIdx();
if(tableIdx == CGolryunBattle::TWOGYUN_100000_ITEM_INDEX ||
tableIdx == CGolryunBattle::TWOGYUN_1000000_ITEM_INDEX)
{
if( battlIdx == curBattleIdx &&
level == g_golryunManagerTable[cnt].levelMin &&
serial == pTournament->m_iTournamentGUID)
{
invCnt++;
}
}
}
int depotCnt=0;
for( i = 0; i < MAX_DEPOT_SIZE; i ++ )
{
if( g_cgv.myCharacterInfo->depot[i] < 0 ) continue;
int itemIdx = g_cgv.myCharacterInfo->depot[i];
int tableIdx = g_cgv.myCharacterInfo->item[itemIdx].itemTableIdx;
int battlIdx = g_cgv.myCharacterInfo->item[itemIdx].optionIdx[0];
int level = g_cgv.myCharacterInfo->item[itemIdx].optionIdx[1];
int serial = g_cgv.myCharacterInfo->item[itemIdx].experience;
int curBattleIdx = g_GolryunBattle.GetBattleIdx();
int cnt = g_GolryunBattle.GetTournamentIdx();
if(tableIdx == CGolryunBattle::TWOGYUN_100000_ITEM_INDEX ||
tableIdx == CGolryunBattle::TWOGYUN_1000000_ITEM_INDEX)
{
if( battlIdx == curBattleIdx &&
level == g_golryunManagerTable[cnt].levelMin &&
serial == pTournament->m_iTournamentGUID)
{
depotCnt++;
}
}
}
return invCnt + depotCnt;
}
void CIFBattleTicketWin::UpdateTicketList()
{
char buffer[256];
for( int i=0; i<m_JoinerCnt; i++ )
{
sprintf( buffer, "%d", i+1 );
g_chatManager->DrawText( m_textCtl[IT_TICKET_LIST_NUMBER]->GetXPos(), m_textCtl[IT_TICKET_LIST_NUMBER]->GetYPos()+(i+1)*TICKET_LIST_LINE_HEIGHT+2, buffer, 109, 13, CHAT_ARRANGE_OVERSIZECUT );
int jobIdx = m_ticketList[i].job;
strcpy( buffer, g_LPACK.GetMassage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_PC_JOB, jobIdx ) );
g_chatManager->DrawText( m_textCtl[IT_TICKET_LIST_CLASS]->GetXPos(), m_textCtl[IT_TICKET_LIST_CLASS]->GetYPos()+(i+1)*TICKET_LIST_LINE_HEIGHT+2, buffer, 253, 13, CHAT_ARRANGE_OVERSIZECUT );
sprintf( buffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,347), m_ticketList[i].win, m_ticketList[i].lose );
g_chatManager->DrawText( m_textCtl[IT_TICKET_LIST_WAR_RECORD]->GetXPos(), m_textCtl[IT_TICKET_LIST_WAR_RECORD]->GetYPos()+(i+1)*TICKET_LIST_LINE_HEIGHT+2, buffer, 121, 13, CHAT_ARRANGE_OVERSIZECUT );
sprintf( buffer, "%.2f", m_ticketList[i].shareRate );
g_chatManager->DrawText( m_textCtl[IT_TICKET_LIST_SHARE_RATE]->GetXPos(), m_textCtl[IT_TICKET_LIST_SHARE_RATE]->GetYPos()+(i+1)*TICKET_LIST_LINE_HEIGHT+2, buffer, 49, 13, CHAT_ARRANGE_OVERSIZECUT );
}
}
void CIFBattleTicketWin::SetDisplayMode( bool mode )
{
m_bDisplay = mode;
}
void CIFBattleTicketWin::SetSelectBar( int idx )
{
m_selectBar->Enable();
g_ifMng->m_iPos[IF_TICKET_SELECT_BAR].clientY = m_selectBarSavePos[m_interfaceType] + idx * MAIL_WIN_LIST_LINE_HEIGHT;
m_selectBar->UpdateControl();
m_selectBar->UpdateBuffer();
m_selectBar->Render();
}
CIFShareWin::CIFShareWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
int i;
for( i=0; i<NUM_IT_SHARE; i++ )
m_textCtl[i] = new CIFText( this );
m_titleBar = new CIFControl( this );
m_titleBarBottom = new CIFControl( this );
m_battlePrevBtn = new CIFButtonCtl( this );
m_battleNextBtn = new CIFButtonCtl( this );
m_levelPrevBtn = new CIFButtonCtl( this );
m_levelNextBtn = new CIFButtonCtl( this );
m_changeBtn = new CIFButtonCtl( this );
m_cancelBtn = new CIFButtonCtl( this );
m_bDisplay = false;
m_iShareNak = 0;
m_iBattleCnt = 1;
m_iLevelCnt = 0;
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_SHARE_WINDOW_TYPE );
}
CIFShareWin::~CIFShareWin()
{
}
void CIFShareWin::PrepareControl()
{
CIFControl::PrepareControl( IF_SHARE_WIN );
m_textCtl[IT_SHARE_TITLE]->PrepareControl( IF_SHARE_WIN_TITLE_TEXT );
m_textCtl[IT_SHARE_WIN_SERIAL_BAR]->PrepareControl( IF_SHARE_WIN_SERIAL_BAR );
m_textCtl[IT_SHARE_WIN_GUID_BAR]->PrepareControl( IF_SHARE_WIN_GUID_BAR );
m_textCtl[IT_SHARE_WIN_RATE_BAR]->PrepareControl( IF_SHARE_WIN_RATE_BAR );
m_textCtl[IT_SHARE_WIN_LEVEL]->PrepareControl( IF_SHARE_WIN_LEVEL_TEXT );
m_textCtl[IT_SHARE_WIN_INVEN_POS]->PrepareControl( IF_SHARE_WIN_INVEN_POS );
m_textCtl[IT_SHARE_WIN_NAK]->PrepareControl( IF_SHARE_WIN_NAK_TEXT );
m_textCtl[IT_SHARE_WIN_NAK_BAR]->PrepareControl( IF_SHARE_WIN_NAK_BAR );
m_titleBar->PrepareControl( IF_SHARE_WIN_TITLE_BAR );
m_titleBarBottom->PrepareControl( IF_SHARE_WIN_TITLE_BOTTOM );
m_battlePrevBtn->PrepareControl( IF_SHARE_WIN_BATTLE_PREV_BTN_0 );
m_battleNextBtn->PrepareControl( IF_SHARE_WIN_BATTLE_NEXT_BTN_0 );
m_levelPrevBtn->PrepareControl( IF_SHARE_WIN_LEVEL_PREV_BTN_0 );
m_levelNextBtn->PrepareControl( IF_SHARE_WIN_LEVEL_NEXT_BTN_0 );
m_changeBtn->PrepareControl( IF_SHARE_WIN_EXCHANGE_BTN_0 );
m_cancelBtn->PrepareControl( IF_SHARE_WIN_CANCEL_BTN_0 );
}
int CIFShareWin::WindowFrame()
{
if( !State() ) return IF_CTL_NONE;
char szTemp[256];
m_textCtl[IT_SHARE_TITLE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,181) );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,348), m_iBattleCnt);
m_textCtl[IT_SHARE_WIN_SERIAL_BAR]->SetText(szTemp);
int iBattleIdx = g_GolryunBattle.GetBattleIdx();
if(iBattleIdx == m_iBattleCnt)
{
CurrentBattleInformation();
}
else
{
RecordBattleInformation(m_iBattleCnt);
}
m_textCtl[IT_SHARE_WIN_NAK]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,349) );
strcpy( szTemp, g_ifMng->GetNumberString( m_iShareNak ) );
m_textCtl[IT_SHARE_WIN_NAK_BAR]->SetText( szTemp );
m_changeBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,191) );
m_cancelBtn->SetButtonText( g_LPACK.GetMessage(0,521) );
return( IF_CTL_NONE );
}
void CIFShareWin::CurrentBattleInformation()
{
char szTemp[256];
CGolryunBattle::tagBattle* pBattle = g_GolryunBattle.GetBattleCurrentPointer();
if(pBattle == NULL) return;
if(pBattle->Tournament[m_iLevelCnt].bComplete)
{
if(pBattle->Tournament[m_iLevelCnt].FirstWinner.iFightNum<=0)
{
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,350), g_golryunManagerTable[m_iLevelCnt].levelMin);
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,351), pBattle->Tournament[m_iLevelCnt].m_iTournamentGUID);
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText("");
return;
}
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,352), g_golryunManagerTable[m_iLevelCnt].levelMin,
pBattle->Tournament[m_iLevelCnt].FirstWinner.iFightNum );
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,351), pBattle->Tournament[m_iLevelCnt].m_iTournamentGUID);
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,353), pBattle->Tournament[m_iLevelCnt].m_ShareRate );
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText(szTemp);
}else
{
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,354), g_golryunManagerTable[m_iLevelCnt].levelMin);
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, "");
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText(szTemp);
}
}
void CIFShareWin::RecordBattleInformation(int battleCnt)
{
char szTemp[256];
CGolryunBattle::tagBattle* pRecord = g_GolryunBattle.FindBattleRecordPointer(battleCnt);
if(pRecord == NULL) return;
if(pRecord->Tournament[m_iLevelCnt].bComplete)
{
if(pRecord->Tournament[m_iLevelCnt].FirstWinner.iFightNum<=0)
{
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,350), g_golryunManagerTable[m_iLevelCnt].levelMin);
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,351), pRecord->Tournament[m_iLevelCnt].m_iTournamentGUID);
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText("");
return;
}
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,352), g_golryunManagerTable[m_iLevelCnt].levelMin,
pRecord->Tournament[m_iLevelCnt].FirstWinner.iFightNum );
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,351), pRecord->Tournament[m_iLevelCnt].m_iTournamentGUID);
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,353), pRecord->Tournament[m_iLevelCnt].m_ShareRate );
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText(szTemp);
}else
{
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,354), g_golryunManagerTable[m_iLevelCnt].levelMin);
m_textCtl[IT_SHARE_WIN_LEVEL]->SetText( szTemp );
sprintf( szTemp, "");
m_textCtl[IT_SHARE_WIN_GUID_BAR]->SetText(szTemp);
m_textCtl[IT_SHARE_WIN_RATE_BAR]->SetText(szTemp);
}
}
void CIFShareWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_titleBar->Render();
m_titleBarBottom->Render();
m_battlePrevBtn->Render();
m_battleNextBtn->Render();
m_levelPrevBtn->Render();
m_levelNextBtn->Render();
m_changeBtn->RenderTextBtn();
m_cancelBtn->RenderTextBtn();
g_ifMng->m_iconCtl->BeginFrame();
{
for( int i = 0; i < MAX_SHARE_INVENTORY_SIZE; i ++ )
{
int itemIdx, itemTableIdx, cx, cy;
itemIdx = g_cgv.myCharacterInfo->shareInventory[i];
if( itemIdx >= 0 )
{
cx = m_textCtl[IT_SHARE_WIN_INVEN_POS]->m_info.clientX + ( i % 6 ) * 34;
cy = m_textCtl[IT_SHARE_WIN_INVEN_POS]->m_info.clientY + ( i / 6 ) * 33;
itemTableIdx = g_cgv.myCharacterInfo->item[itemIdx].itemTableIdx;
g_ifMng->m_iconCtl->Draw( cx, cy, IF_ICON_ITEM, g_itemTable[itemTableIdx].iconItemID );
}
}
}
g_ifMng->m_iconCtl->EndFrame();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_SHARE_TITLE]->Render();
m_textCtl[IT_SHARE_WIN_SERIAL_BAR]->Render();
m_textCtl[IT_SHARE_WIN_GUID_BAR]->Render();
m_textCtl[IT_SHARE_WIN_RATE_BAR]->Render();
m_textCtl[IT_SHARE_WIN_LEVEL]->Render();
m_textCtl[IT_SHARE_WIN_NAK]->Render();
m_textCtl[IT_SHARE_WIN_NAK_BAR]->Render();
}
g_chatManager->EndFrame();
}
int CIFShareWin::WindowSelection()
{
int ret;
ret = m_titleBar->Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFShareWin::WindowProcess()
{
int itemIdx, mouseItemIdx;
int x, y, pos;
int mx, my, temp;
if( m_battlePrevBtn->ProcessButton() == IF_CTL_SELECT )
{
int iBattleIdx = g_GolryunBattle.GetBattleIdx();
int record_start_idx = iBattleIdx - CGolryunBattle::MAX_NUM_BATTLE_RECORD;
if(record_start_idx <= 1) record_start_idx = 1;
if( m_iBattleCnt <= record_start_idx )
m_iBattleCnt = record_start_idx;
else
m_iBattleCnt--;
}
else if( m_battleNextBtn->ProcessButton() == IF_CTL_SELECT )
{
int iBattleIdx = g_GolryunBattle.GetBattleIdx();
if( m_iBattleCnt >= iBattleIdx )
m_iBattleCnt = iBattleIdx;
else
m_iBattleCnt++;
}
if( m_levelPrevBtn->ProcessButton() == IF_CTL_SELECT )
{
if( m_iLevelCnt <= 0 )
m_iLevelCnt = 0;
else
m_iLevelCnt--;
}
else if( m_levelNextBtn->ProcessButton() == IF_CTL_SELECT )
{
int turnCnt = g_GolryunBattle.GetTournamentIdx();
if( m_iLevelCnt >= CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE-1 )
m_iLevelCnt = CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE-1;
else
m_iLevelCnt++;
}
if( m_cancelBtn->ProcessButton() == IF_CTL_SELECT )
{
GTH_SendMessage_ItemSystem_ExchangeClose();
Enable( false );
return IF_CTL_SELECT;
}
if( m_changeBtn->ProcessButton() == IF_CTL_SELECT )
{
GTH_SendMessage_ItemSystem_ExchangePrepare();
return IF_CTL_SELECT;
}
pos = -1;
mx = g_input->GetPosX() - m_textCtl[IT_SHARE_WIN_INVEN_POS]->GetXPos();
my = g_input->GetPosY() - m_textCtl[IT_SHARE_WIN_INVEN_POS]->GetYPos();
if( mx <= 0 || my <= 0 ) return( IF_CTL_NONE );
if( mx >= 34 * 6 || my >= 33 * 3 ) return( IF_CTL_NONE );
temp = mx / 34;
x = temp % 6;
temp = my / 33;
y = temp % 3;
pos = y * 6 + x;
if( pos < 0 || pos >= MAX_SHARE_INVENTORY_SIZE )
{
return( IF_CTL_NONE );
}
itemIdx = g_cgv.myCharacterInfo->shareInventory[pos];
mouseItemIdx = g_cgv.myCharacterInfo->mouseInventory;
if( g_input->GetLBNone() )
{
if( itemIdx < 0 ) return( IF_CTL_NONE );
g_ifMng->InitRolloverText();
g_ifMng->MakeItemRollover( &g_cgv.myCharacterInfo->item[itemIdx] );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), true, 250 );
}
if( g_input->GetLBUp() )
{
if( g_cgv.myCharacterInfo->curItemWeight > g_cgv.myCharacterInfo->calItemWeight )
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( 0, 589 ) );
return( IF_CTL_NONE );
}
if( mouseItemIdx < 0 && itemIdx < 0 ) return IF_CTL_NONE;
GTH_SendMessage_ItemSystem_ExchangeItem( m_iBattleCnt, m_iLevelCnt, pos );
}
return IF_CTL_NONE;
}
void CIFShareWin::InitShareInventory()
{
for( int i = 0; i < MAX_SHARE_INVENTORY_SIZE; i ++ )
{
g_cgv.myCharacterInfo->shareInventory[i] = -1;
}
m_iShareNak = 0;
}
void CIFShareWin::UndoShareInventory()
{
item_t *item;
int itemIdx, inventoryPos;
for( int i = 0; i < MAX_SHARE_INVENTORY_SIZE; i ++ )
{
itemIdx = g_cgv.myCharacterInfo->shareInventory[i];
if( itemIdx < 0 ) continue;
item = &g_cgv.myCharacterInfo->item[itemIdx];
int stackItemIdx = GTH_StackMyItem( item );
if( stackItemIdx >= 0 )
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += item->durability + 1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability + 1 >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
GTH_DeleteMyItem( item );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos();
if( inventoryPos >= 0 )
{
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
}
}
}
InitShareInventory();
Enable( false );
}
CIFTournamentWin::CIFTournamentWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
int i;
for( i=0; i<NUM_IT_TOURNAMENT; i++ )
m_textCtl[i] = new CIFText( this );
for( i=0; i<30; i++ )
m_loseX[i] = new CIFControl( this );
m_closeBtn = new CIFButtonCtl( this );
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_TOURNAMENT_WINDOW_TYPE );
}
CIFTournamentWin::~CIFTournamentWin()
{
}
void CIFTournamentWin::PrepareControl()
{
CIFControl::PrepareControl( IF_TOURNAMENT_WIN );
m_textCtl[IT_TOURNAMENT_TITLE]->PrepareControl( IF_TOURNAMENT_TITLE_TEXT );
m_textCtl[IT_TOURNAMENT_STEP0_NUMBER]->PrepareControl( IF_TOURNAMENT_STEP0_NUMBER );
m_textCtl[IT_TOURNAMENT_STEP1_NUMBER]->PrepareControl( IF_TOURNAMENT_STEP1_NUMBER );
m_textCtl[IT_TOURNAMENT_STEP2_NUMBER]->PrepareControl( IF_TOURNAMENT_STEP2_NUMBER );
m_textCtl[IT_TOURNAMENT_STEP3_NUMBER]->PrepareControl( IF_TOURNAMENT_STEP3_NUMBER );
m_textCtl[IT_TOURNAMENT_STEP4_NUMBER]->PrepareControl( IF_TOURNAMENT_STEP4_NUMBER );
m_textCtl[IT_TOURNAMENT_WIN_NUMBER]->PrepareControl( IF_TOURNAMENT_WIN_NUMBER );
for( int i=0; i<30; i++ )
{
m_loseX[i]->PrepareControl( IF_TOURNAMENT_LOSE_DISPLAY_0 + i);
}
m_closeBtn->PrepareControl( IF_TOURNAMENT_CLOSE_BTN_0 );
m_textCtl[IT_TOURNAMENT_TITLE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,355) );
m_closeBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,936) );
}
int CIFTournamentWin::WindowFrame()
{
return( IF_CTL_NONE );
}
void CIFTournamentWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
int i,j,k=0;
for(i=0; i<CGolryunBattle::MAX_NUM_MATCH_PER_TOURNAMENT; i++)
{
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if((TRUE == pMatch->bComplete) && (FALSE == pMatch->Fighter[j].bWin)){
m_loseX[k]->Render();
}
k++;
}
}
m_closeBtn->RenderTextBtn();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_TOURNAMENT_TITLE]->Render();
UpdateTournamentList();
}
g_chatManager->EndFrame();
}
int CIFTournamentWin::WindowSelection()
{
int ret;
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFTournamentWin::WindowProcess()
{
if( m_closeBtn->ProcessButton() == IF_CTL_SELECT )
{
Enable( false );
return IF_CTL_SELECT;
}
return IF_CTL_NONE;
}
void CIFTournamentWin::UpdateTournamentList()
{
int i,j,k;
char buffer[32];
CGolryunBattle::tagBattle* pBattle = g_GolryunBattle.GetBattleCurrentPointer();
for(i=0; i<CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
if(!pBattle->Tournament[i].bComplete) continue;
if(pBattle->Tournament[i].FirstWinner.iFightNum <= 0) continue;
sprintf( buffer, "%d", pBattle->Tournament[i].FirstWinner.iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_WIN_NUMBER]->GetXPos()+i*48,
m_textCtl[IT_TOURNAMENT_WIN_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
k=0;
for(i=0; i<8; i++)
{
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if(pMatch->Fighter[j].iFightNum <= 0) continue;
sprintf( buffer, "%d", pMatch->Fighter[j].iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_STEP0_NUMBER]->GetXPos()+35*j+87*k,
m_textCtl[IT_TOURNAMENT_STEP0_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
k++;
}
k=0;
for(i=8; i<12; i++)
{
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if(pMatch->Fighter[j].iFightNum <= 0) continue;
sprintf( buffer, "%d", pMatch->Fighter[j].iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_STEP1_NUMBER]->GetXPos()+87*j+174*k,
m_textCtl[IT_TOURNAMENT_STEP1_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
k++;
}
k=0;
for(i=12; i<14; i++)
{
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if(pMatch->Fighter[j].iFightNum <= 0) continue;
sprintf( buffer, "%d", pMatch->Fighter[j].iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_STEP2_NUMBER]->GetXPos()+174*j+347*k,
m_textCtl[IT_TOURNAMENT_STEP2_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
k++;
}
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(14);
if(pMatch->Fighter[j].iFightNum <= 0) continue;
sprintf( buffer, "%d", pMatch->Fighter[j].iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_STEP3_NUMBER]->GetXPos()+347*j,
m_textCtl[IT_TOURNAMENT_STEP3_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
CGolryunBattle::tagTournament* pTournament = g_GolryunBattle.GetTournamentPointer();
if(pTournament->FirstWinner.iFightNum <= 0) return;
sprintf( buffer, "%d", pTournament->FirstWinner.iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_STEP4_NUMBER]->GetXPos(),
m_textCtl[IT_TOURNAMENT_STEP4_NUMBER]->GetYPos(), buffer, 16, 13, CHAT_ARRANGE_CENTER );
}
void CIFTournamentWin::SetDisplayMode( bool mode )
{
}
void CIFTournamentWin::SetSelectBar( int idx )
{
}
CIFPrizeWin::CIFPrizeWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
for( int i=0; i<NUM_IT_PRIZE; i++ )
m_textCtl[i] = new CIFText( this );
m_closeBtn = new CIFButtonCtl( this );
m_scrollBar = new CIFScrollBar( this );
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_PRIZE_WINDOW_TYPE );
}
CIFPrizeWin::~CIFPrizeWin()
{
}
void CIFPrizeWin::PrepareControl()
{
CIFControl::PrepareControl( IF_PRIZE_WIN );
m_textCtl[IT_PRIZE_GRADE]->PrepareControl( IF_PRIZE_GRADE_TEXT );
m_textCtl[IT_PRIZE_ITEM_IMAGE]->PrepareControl( IF_PRIZE_ITEM_IMAGE_TEXT );
m_textCtl[IT_PRIZE_STACK_NUM]->PrepareControl( IF_PRIZE_STACK_NUM_TEXT );
m_textCtl[IT_PRIZE_ITEM_NAME]->PrepareControl( IF_PRIZE_ITEM_NAME_TEXT );
m_textCtl[IT_PRIZE_GRADE_POS]->PrepareControl( IF_PRIZE_GRADE_POS );
m_textCtl[IT_PRIZE_ITEM_IMAGE_POS]->PrepareControl( IF_PRIZE_ITEM_IMAGE_POS );
m_textCtl[IT_PRIZE_STACK_NUM_POS]->PrepareControl( IF_PRIZE_STACK_NUM_POS );
m_textCtl[IT_PRIZE_ITEM_NAME_POS]->PrepareControl( IF_PRIZE_ITEM_NAME_POS );
m_textCtl[IT_PRIZE_USER_NAME]->PrepareControl( IF_PRIZE_USER_NAME_TEXT );
m_textCtl[IT_PRIZE_USER_NAME_POS]->PrepareControl( IF_PRIZE_USER_NAME_POS );
m_closeBtn->PrepareControl( IF_PRIZE_CLOSE_BTN_0 );
m_scrollBar->PrepareControl( IF_PRIZE_SCROLL );
m_scrollBar->SetBarPosition( 0, 0 );
}
int CIFPrizeWin::WindowFrame()
{
if( !State() ) return IF_CTL_NONE;
m_textCtl[IT_PRIZE_GRADE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,182) );
m_textCtl[IT_PRIZE_ITEM_IMAGE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,492) );
m_textCtl[IT_PRIZE_STACK_NUM]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,356) );
m_textCtl[IT_PRIZE_ITEM_NAME]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,184) );
m_textCtl[IT_PRIZE_USER_NAME]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,357) );
m_closeBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,936) );
if( CGolryunBattle::MAX_NUM_PRIZE_LIST_PER_BATTLE - 8 > 0 && CGolryunBattle::MAX_NUM_PRIZE_LIST_PER_BATTLE - 8 != m_scrollBar->m_max )
{
m_scrollBar->SetBarPosition( CGolryunBattle::MAX_NUM_PRIZE_LIST_PER_BATTLE - 8, m_scrollBar->m_current );
}
else if( CGolryunBattle::MAX_NUM_PRIZE_LIST_PER_BATTLE - 8 <= 0 )
{
m_scrollBar->SetBarPosition( 0, 0 );
}
return IF_CTL_NONE;
}
void CIFPrizeWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_closeBtn->RenderTextBtn();
m_scrollBar->Render();
int itemTableIdx, cx, cy;
g_ifMng->m_iconCtl->BeginFrame();
{
for( int i = 0; i < 3; i ++ )
{
{
cx = m_textCtl[IT_PRIZE_ITEM_IMAGE_POS]->m_info.clientX;
cy = m_textCtl[IT_PRIZE_ITEM_IMAGE_POS]->m_info.clientY + i*47;
itemTableIdx = 456+i;
g_ifMng->m_iconCtl->Draw( cx, cy, IF_ICON_ITEM, g_itemTable[itemTableIdx].iconItemID );
}
}
}
g_ifMng->m_iconCtl->EndFrame();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_PRIZE_GRADE]->Render();
m_textCtl[IT_PRIZE_ITEM_IMAGE]->Render();
m_textCtl[IT_PRIZE_STACK_NUM]->Render();
m_textCtl[IT_PRIZE_ITEM_NAME]->Render();
m_textCtl[IT_PRIZE_USER_NAME]->Render();
UpdatePrizeList();
UpdatePrizeUserList();
}
g_chatManager->EndFrame();
}
int CIFPrizeWin::WindowSelection()
{
return( IF_CTL_NONE );
}
int CIFPrizeWin::WindowProcess()
{
if( m_closeBtn->ProcessButton() == IF_CTL_SELECT )
{
Enable( false );
return IF_CTL_SELECT;
}
if( m_scrollBar->ProcessScrollBar() == IF_CTL_SELECT )
{
return IF_CTL_SELECT;
}
return IF_CTL_NONE;
}
void CIFPrizeWin::UpdatePrizeList()
{
char buffer[256];
for( int i=0; i<3; i++ )
{
sprintf( buffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,358), i+1 );
g_chatManager->DrawText( m_textCtl[IT_PRIZE_GRADE_POS]->GetXPos(), m_textCtl[IT_PRIZE_GRADE_POS]->GetYPos()+i*49, buffer, 50, 13, CHAT_ARRANGE_OVERSIZECUT );
sprintf( buffer, "%d", 10*(i+1));
g_chatManager->DrawText( m_textCtl[IT_PRIZE_STACK_NUM_POS]->GetXPos(), m_textCtl[IT_PRIZE_STACK_NUM_POS]->GetYPos()+i*49, buffer, 50, 13, CHAT_ARRANGE_OVERSIZECUT );
sprintf( buffer, "%s", g_itemTable[456+i].name );
g_chatManager->DrawText( m_textCtl[IT_PRIZE_ITEM_NAME_POS]->GetXPos(), m_textCtl[IT_PRIZE_ITEM_NAME_POS]->GetYPos()+i*49, buffer, 121, 13, CHAT_ARRANGE_OVERSIZECUT );
}
}
void CIFPrizeWin::UpdatePrizeUserList()
{
char buffer[256];
int pos = m_scrollBar->m_current;
CGolryunBattle::tagBattle *pBattle = g_GolryunBattle.GetBattleCurrentPointer();
for( int i=pos; i<8+pos; i++ )
{
if(pBattle->m_PrizeNumber[i] <= 0) continue;
if(i<1)
sprintf( buffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,359), pBattle->m_PrizeNumber[i]);
else if(i<6)
sprintf( buffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,360), pBattle->m_PrizeNumber[i]);
else if(i<16)
sprintf( buffer, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,380), pBattle->m_PrizeNumber[i]);
g_chatManager->DrawText( m_textCtl[IT_PRIZE_USER_NAME_POS]->GetXPos(), m_textCtl[IT_PRIZE_USER_NAME_POS]->GetYPos()+18*(i-pos), buffer, 300, 13, CHAT_ARRANGE_OVERSIZECUT );
}
}
void CIFPrizeWin::SetSelectBar( int idx )
{
}
CIFGolryunInfoWin::CIFGolryunInfoWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
m_textCtl = new CIFText( this );
m_title = new CIFControl( this );
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_BATTLE_INFO_WINDOW_TYPE );
m_RemainTime =0;
m_bTimeOver = false;
}
CIFGolryunInfoWin::~CIFGolryunInfoWin()
{
}
void CIFGolryunInfoWin::PrepareControl()
{
CIFControl::PrepareControl( IF_GUILD_BATTLE_INFO_WIN );
m_textCtl->PrepareControl(IF_GUILD_BATTLE_TIME);
}
void CIFGolryunInfoWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_textCtl->Render();
}
int CIFGolryunInfoWin::WindowFrame()
{
if( !State() ) return IF_CTL_NONE;
char szTemp[256];
if(m_RemainTime<0) m_RemainTime=0;
sprintf(szTemp, "%d(min) %d(sec)", m_RemainTime/60000, (m_RemainTime%60000) / 1000);
m_textCtl->SetText(szTemp);
return IF_CTL_NONE;
}
int CIFGolryunInfoWin::WindowProcess()
{
return IF_CTL_NONE;
}
int CIFGolryunInfoWin::WindowSelection()
{
return IF_CTL_NONE;
}
CIFObserverMenuWin::CIFObserverMenuWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
m_twogyunBtn = new CIFButtonCtl( this );
m_shareBtn = new CIFButtonCtl( this );
m_seedtableBtn = new CIFButtonCtl( this );
m_closeBtn = new CIFButtonCtl( this );
Enable( true );
g_ifMng->AddFocus( this );
SetWindowType( IF_OBSERVER_MENU_WINDOW_TYPE );
}
CIFObserverMenuWin::~CIFObserverMenuWin()
{
}
void CIFObserverMenuWin::PrepareControl()
{
CIFControl::PrepareControl( IF_OBSERVER_MENU_WIN );
m_twogyunBtn->PrepareControl( IF_OBSERVER_MENU_WIN_TWOGYUN_BTN_0 );
m_shareBtn->PrepareControl( IF_OBSERVER_MENU_WIN_SHARE_BTN_0 );
m_seedtableBtn->PrepareControl( IF_OBSERVER_MENU_WIN_SEEDTABLE_BTN_0 );
m_closeBtn->PrepareControl( IF_OBSERVER_MENU_WIN_CLOSE_BTN_0 );
}
int CIFObserverMenuWin::WindowFrame()
{
if( !State() ) return( IF_CTL_NONE );
return IF_CTL_NONE;
}
void CIFObserverMenuWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_twogyunBtn->Render();
m_shareBtn->Render();
m_seedtableBtn->Render();
m_closeBtn->Render();
}
int CIFObserverMenuWin::WindowSelection()
{
return IF_CTL_NONE;
}
int CIFObserverMenuWin::WindowProcess()
{
if( m_twogyunBtn->ProcessButton() == IF_CTL_SELECT )
{
g_GolryunBattle_Encoder.SendOpenBattleTicket();
return( IF_CTL_SELECT );
}
else if( m_twogyunBtn->Selection() == IF_IN_POS )
{
g_ifMng->InitRolloverText();
g_ifMng->AddRolloverText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,458) );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), false );
}
if( m_shareBtn->ProcessButton() == IF_CTL_SELECT )
{
g_GolryunBattle_Encoder.SendOpenShareWin();
return( IF_CTL_SELECT );
}
else if( m_shareBtn->Selection() == IF_IN_POS )
{
g_ifMng->InitRolloverText();
g_ifMng->AddRolloverText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,459) );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), false );
}
if( m_seedtableBtn->ProcessButton() == IF_CTL_SELECT )
{
g_GolryunBattle_Encoder.SendDisplayTournament();
return( IF_CTL_SELECT );
}
else if( m_seedtableBtn->Selection() == IF_IN_POS )
{
g_ifMng->InitRolloverText();
g_ifMng->AddRolloverText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,460) );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), false );
}
if( m_closeBtn->ProcessButton() == IF_CTL_SELECT )
{
g_GolryunBattle.SetObserverMode(CGolryunBattle::eObserverMode::general);
memcpy(g_pApp->m_myCharacter->position, g_GolryunBattle.m_OldPosition, sizeof(vec3_t));
g_pApp->m_myCharacter->m_bObserveMode = FALSE;
g_camera.m_maxCamDist = -350.0f;
g_camera.m_distance = -350.0f;
g_ifMng->m_observerInfoWin->Enable(false);
g_GolryunBattle_Encoder.SendObserveEnd();
GTH_SendEventMessage_Idle();
GTH_UpdateSendedZPos();
return( IF_CTL_SELECT );
}
else if( m_closeBtn->Selection() == IF_IN_POS )
{
g_ifMng->InitRolloverText();
g_ifMng->AddRolloverText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,461) );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), false );
}
return IF_CTL_NONE;
}
CIFObserverInfoWin::CIFObserverInfoWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
for( int i=0; i<NUM_IT_OBSERVER_INFO; i++ )
m_textCtl[i] = new CIFText( this );
m_redFighterRaBar = new CIFBarCtl( this );
m_redFighterSaBar = new CIFBarCtl( this );
m_blueFighterRaBar = new CIFBarCtl( this );
m_blueFighterSaBar = new CIFBarCtl( this );
Enable( false );
m_redFighterRaBar->Enable( false );
m_redFighterSaBar->Enable( false );
m_blueFighterRaBar->Enable( false );
m_blueFighterSaBar->Enable( false );
m_RemainTime = 0;
m_redFighterNumber = 0;
m_blueFighterNumber = 0;
m_redFighterCurRa = 0;
m_redFighterMaxRa = 0;
m_redFighterCurSa = 0;
m_redFighterMaxSa = 0;
m_blueFighterCurRa = 0;
m_blueFighterMaxRa = 0;
m_blueFighterCurSa = 0;
m_blueFighterMaxSa = 0;
g_ifMng->AddFocus( this );
SetWindowType( IF_OBSERVER_INFO_WINDOW_TYPE );
}
CIFObserverInfoWin::~CIFObserverInfoWin()
{
}
void CIFObserverInfoWin::PrepareControl()
{
CIFControl::PrepareControl( IF_OBSERVER_INFO_WIN );
m_textCtl[IT_BATTLE_TIME]->PrepareControl( IF_OBSERVER_INFO_WIN_TIME );
m_textCtl[IT_RED_FIGHTER_NAME]->PrepareControl( IF_OBSERVER_INFO_WIN_RED );
m_textCtl[IT_BLUE_FIGHTER_NAME]->PrepareControl( IF_OBSERVER_INFO_WIN_BLUE );
m_redFighterRaBar->PrepareControl( IF_OBSERVER_INFO_WIN_RED_RA_BAR );
m_redFighterSaBar->PrepareControl( IF_OBSERVER_INFO_WIN_RED_SA_BAR );
m_blueFighterRaBar->PrepareControl( IF_OBSERVER_INFO_WIN_BLUE_RA_BAR );
m_blueFighterSaBar->PrepareControl( IF_OBSERVER_INFO_WIN_BLUE_SA_BAR );
}
int CIFObserverInfoWin::WindowFrame()
{
if( !State() ) return IF_CTL_NONE;
char szTemp[256];
sprintf(szTemp, "%d : %d", m_RemainTime/60000, (m_RemainTime%60000) / 1000);
m_textCtl[IT_BATTLE_TIME]->SetColor(D3DCOLOR_ARGB(255, 255, 255, 0));
m_textCtl[IT_BATTLE_TIME]->SetText(szTemp);
if(m_redFighterNumber<=0 || m_blueFighterNumber<=0)
{
m_textCtl[IT_RED_FIGHTER_NAME]->SetText( "" );
m_textCtl[IT_BLUE_FIGHTER_NAME]->SetText( "" );
m_redFighterRaBar->Enable(false);
m_redFighterSaBar->Enable(false);
m_blueFighterRaBar->Enable(false);
m_blueFighterSaBar->Enable(false);
g_pApp->m_myCharacter->position[0] = 2108;
g_pApp->m_myCharacter->position[1] = -11771;
g_pApp->m_myCharacter->position[2] = -300;
g_GolryunBattle.m_ObserverPos[0] = 2108;
g_GolryunBattle.m_ObserverPos[1] = -11771;
g_GolryunBattle.m_ObserverPos[2] = 180;
return IF_CTL_NONE;
}
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,396), m_redFighterNumber );
m_textCtl[IT_RED_FIGHTER_NAME]->SetText( szTemp );
sprintf( szTemp, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,396), m_blueFighterNumber );
m_textCtl[IT_BLUE_FIGHTER_NAME]->SetText( szTemp );
int i;
Fx_CHARACTER_t *character=NULL;
int numCharacter=0;
vec3_t redPos, bluePos;
memset(redPos, 0, sizeof(vec3_t));
memset(bluePos, 0, sizeof(vec3_t));
character = &g_charManager->m_Characters[0];
numCharacter = g_charManager->m_iNumCharacters;
for (i=0; i<numCharacter; i++, character++)
{
if(character->entityType != ENTITY_PC) continue;
if(character->m_JoinNum<=0) continue;
if(character->m_JoinNum == m_redFighterNumber)
{
m_redFighterRaBar->Enable();
m_redFighterRaBar->UpdateBarState_Inverse( character->curRA, character->calMaxRA );
m_redFighterSaBar->Enable();
m_redFighterSaBar->UpdateBarState_Inverse( character->curSA, character->calMaxSA );
redPos[0] = character->position[0];
redPos[1] = character->position[1];
}
if(character->m_JoinNum == m_blueFighterNumber)
{
m_blueFighterRaBar->Enable();
m_blueFighterRaBar->UpdateBarState( character->curRA, character->calMaxRA );
m_blueFighterSaBar->Enable();
m_blueFighterSaBar->UpdateBarState( character->curSA, character->calMaxSA );
bluePos[0] = character->position[0];
bluePos[1] = character->position[1];
}
g_pApp->m_myCharacter->position[0] = (redPos[0]+bluePos[0])/2;
g_pApp->m_myCharacter->position[1] = (redPos[1]+bluePos[1])/2;
g_pApp->m_myCharacter->position[2] = -300;
g_GolryunBattle.m_ObserverPos[0] = (redPos[0]+bluePos[0])/2;
g_GolryunBattle.m_ObserverPos[1] = (redPos[1]+bluePos[1])/2;
g_GolryunBattle.m_ObserverPos[2] = 180;
if(g_GolryunBattle.m_ObserverPos[0]>2894.0f || g_GolryunBattle.m_ObserverPos[0]<1331.0f ||
g_GolryunBattle.m_ObserverPos[1]> -10992.0f || g_GolryunBattle.m_ObserverPos[1]< -12554.0f)
{
g_GolryunBattle.m_ObserverPos[0] = 2108;
g_GolryunBattle.m_ObserverPos[1] = -11771;
g_GolryunBattle.m_ObserverPos[2] = 180;
}
}
return( IF_CTL_NONE );
}
void CIFObserverInfoWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_redFighterRaBar->Render();
m_redFighterSaBar->Render();
m_blueFighterRaBar->Render();
m_blueFighterSaBar->Render();
g_chatManager->SetOutputType( CHAT_OUTPUT_SHADOW );
g_chatManager->BeginFrame();
{
m_textCtl[IT_BATTLE_TIME]->Render();
m_textCtl[IT_RED_FIGHTER_NAME]->Render();
m_textCtl[IT_BLUE_FIGHTER_NAME]->Render();
}
g_chatManager->EndFrame();
}
int CIFObserverInfoWin::WindowSelection()
{
int ret;
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFObserverInfoWin::WindowProcess()
{
if( Selection() == IF_LBUP )
{
g_GameTarget.GTH_ChangeTarget( g_pApp->m_myCharacter );
}
return IF_CTL_NONE;
}
CIFTournamentMiniWin::CIFTournamentMiniWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
int i;
for( i=0; i<NUM_IT_TOURNAMENT_MINI; i++ )
m_textCtl[i] = new CIFText( this );
for( i=0; i<TOURNAMENT_NUMBER_MAX_NUM; i++ )
m_textNumCtl[i] = new CIFText( this );
for( i=0; i<LOSE_DISPLAY_MAX_NUM; i++ )
m_loseX[i] = new CIFControl( this );
m_closeBtn = new CIFButtonCtl( this );
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_TOURNAMENT_MINI_WINDOW_TYPE );
}
CIFTournamentMiniWin::~CIFTournamentMiniWin()
{
}
void CIFTournamentMiniWin::PrepareControl()
{
CIFControl::PrepareControl( IF_TOURNAMENT_MINI_WIN );
m_textCtl[IT_TOURNAMENT_MINI_TITLE]->PrepareControl( IF_TOURNAMENT_MINI_TITLE_TEXT );
m_textCtl[IT_TOURNAMENT_MINI_WIN_NUMBER]->PrepareControl( IF_TOURNAMENT_MINI_WIN_NUMBER );
int i;
for( i=0; i<TOURNAMENT_NUMBER_MAX_NUM; i++ )
m_textNumCtl[i]->PrepareControl( IF_TOURNAMENT_MINI_NUMBER_0 + i);
for( i=0; i<LOSE_DISPLAY_MAX_NUM; i++ )
m_loseX[i]->PrepareControl( IF_TOURNAMENT_MINI_LOSE_0 + i);
m_closeBtn->PrepareControl( IF_TOURNAMENT_MINI_CLOSE_BTN_0 );
m_textCtl[IT_TOURNAMENT_MINI_TITLE]->SetText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,355) );
m_closeBtn->SetButtonText( g_LPACK.GetMassage(LPACK_TYPE_NORMAL,936) );
}
int CIFTournamentMiniWin::WindowFrame()
{
return( IF_CTL_NONE );
}
void CIFTournamentMiniWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
int i,j,k=0;
for(i=0; i<CGolryunBattle::MAX_NUM_MATCH_PER_TOURNAMENT; i++)
{
for(j=0; j<2; j++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if((TRUE == pMatch->bComplete) &&
(FALSE == pMatch->Fighter[j].bWin)){
m_loseX[k]->Render();
}
k++;
}
}
m_closeBtn->RenderTextBtn();
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_TOURNAMENT_MINI_TITLE]->Render();
UpdateTournamentList();
}
g_chatManager->EndFrame();
}
int CIFTournamentMiniWin::WindowSelection()
{
int ret;
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
int CIFTournamentMiniWin::WindowProcess()
{
if( m_closeBtn->ProcessButton() == IF_CTL_SELECT )
{
Enable( false );
return IF_CTL_SELECT;
}
return IF_CTL_NONE;
}
void CIFTournamentMiniWin::UpdateTournamentList()
{
int i,j,k;
char buffer[32];
CGolryunBattle::tagBattle* pBattle = g_GolryunBattle.GetBattleCurrentPointer();
if(pBattle == NULL) return;
for(i=0; i<CGolryunBattle::MAX_NUM_TOURNAMENT_PER_BATTLE; i++)
{
if(!pBattle->Tournament[i].bComplete) continue;
if(pBattle->Tournament[i].FirstWinner.iFightNum <= 0) continue;
sprintf( buffer, "%d", pBattle->Tournament[i].FirstWinner.iFightNum );
g_chatManager->DrawText(m_textCtl[IT_TOURNAMENT_MINI_WIN_NUMBER]->GetXPos()+i*31,
m_textCtl[IT_TOURNAMENT_MINI_WIN_NUMBER]->GetYPos(), buffer, 12, 14, CHAT_ARRANGE_CENTER );
}
k=0;
for(i=0; i<CGolryunBattle::MAX_NUM_MATCH_PER_TOURNAMENT; i++)
{
CGolryunBattle::tagMatch* pMatch = g_GolryunBattle.GetMatchPointer(i);
if(pMatch == NULL) continue;
for(j=0; j<2; j++)
{
if(pMatch->Fighter[j].iFightNum > 0)
{
sprintf( buffer, "%d", pMatch->Fighter[j].iFightNum );
g_chatManager->DrawText(m_textNumCtl[k]->GetXPos(),
m_textNumCtl[k]->GetYPos(), buffer, 12, 14, CHAT_ARRANGE_CENTER );
}
k++;
}
}
CGolryunBattle::tagTournament* pTournament = g_GolryunBattle.GetTournamentPointer();
if(pTournament == NULL) return;
if(pTournament->FirstWinner.iFightNum <= 0) return;
sprintf( buffer, "%d", pTournament->FirstWinner.iFightNum );
g_chatManager->DrawText(m_textNumCtl[30]->GetXPos(),
m_textNumCtl[30]->GetYPos(), buffer, 12, 14, CHAT_ARRANGE_CENTER );
}
| C++ |
#ifndef _GOLRYUNBATTLE_H_
#define _GOLRYUNBATTLE_H_
struct TicketSerialInfo
{
int TIME : 8;
int LEVEL : 8;
int WINNUM : 6;
};
class CGolryunBattle
{
public :
enum {
GOLRYUN_BATTLE_MAP_INDEX = 21,
MAX_NUM_FIGHTER_PER_TOURNAMENT = 16,
MAX_NUM_TOURNAMENT_PER_BATTLE = 7,
MAX_NUM_MATCH_PER_TOURNAMENT = 15,
MAX_NUM_BATTLE_RECORD = 10,
MAX_NUM_PRIZE_LIST_PER_BATTLE = 16,
ENTERANCE_TICKET_ITEM_INDEX = 450,
TWOGYUN_100000_ITEM_INDEX = 456,
TWOGYUN_1000000_ITEM_INDEX = 457,
BOKGYUN_ITEM_INDEX = 458,
GOLDBAR_ITEM_INDEX = 459,
};
enum eManor
{
normal =0,
week,
month,
ramification,
year,
};
enum eRoundStep{
round_16 = 16,
round_8 =8,
round_4 =4,
round_final =2,
};
enum eObserverMode{
general =0,
observe ,
};
struct tagFighter{
bool bWin;
int iFightNum;
};
struct tagMatch{
public:
BOOL bComplete;
struct tagFighter Fighter[2];
};
struct tagTournament{
public:
BOOL bComplete;
int m_iTournamentGUID;
float m_ShareRate;
struct tagFighter FirstWinner;
struct tagFighter SecondWinner;
};
struct tagBattle{
public:
BOOL bComplete;
int m_iBattleGUID;
int m_PrizeNumber[MAX_NUM_PRIZE_LIST_PER_BATTLE];
struct tagTournament Tournament[MAX_NUM_TOURNAMENT_PER_BATTLE];
};
private :
unsigned int m_iUpdateTime;
unsigned int m_iStartTime;
int m_iStartCnt;
int m_iStatus;
tagMatch *m_Match;
tagTournament *m_Tournament;
int m_iTournamentIdx;
tagBattle *m_BattleCurrent;
int m_iBattleIdx;
tagBattle *m_BattleRecord;
eObserverMode m_eObserverMode;
public :
vec3_t m_OldPosition;
vec3_t m_ObserverPos;
public :
CGolryunBattle();
virtual ~CGolryunBattle();
public :
void InitMatch();
int InitTournament(tagTournament* pTournament);
void InitBattle(tagBattle* pBattle);
void InitBattleRecord();
void SetStatus(int iStatus);
int GetStatus();
struct tagMatch* GetMatchPointer(const int matchIdx);
struct tagTournament* GetTournamentPointer(){ return m_Tournament; };
struct tagBattle* FindBattleRecordPointer(const int battleIdx);
struct tagBattle* GetBattleCurrentPointer(){ return m_BattleCurrent; };
struct tagBattle* GetBattleRecordPointer(const int battleIdx);
int GetTournamentIdx(){ return m_iTournamentIdx; };
void SetTournamentIdx(int idx){ m_iTournamentIdx = idx; };
int GetBattleIdx(){ return m_iBattleIdx; };
void SetBattleIdx(int idx){ m_iBattleIdx = idx; };
int EncodeSerial(int time,int level,int winNum);
TicketSerialInfo DecodeSerial(int Serial);
void SetManorGrade(Fx_CHARACTER_t *character );
void SetObserverMode(eObserverMode eMode){ m_eObserverMode = eMode; };
eObserverMode GetObserverMode(){ return m_eObserverMode; };
public :
void ProcessTransGolryunBattle();
void ProcessSuggestBattle();
void ProcessEffectCount();
BOOL CheckInventoryMaxSize();
void SetupObserver(void);
void SetupReStartGame(void);
public :
void RecvGolryunBattle();
void RecvTransGolryun();
void RecvTransArayan();
void RecvSuggestBattle();
void RecvActiveBattle();
void RecvOpenBattleTicket();
void RecvShareRate();
void RecvReNewBattleTicket(void);
void RecvOpenShareWin();
void RecvDisplayTournament();
void RecvCheckPrize();
void RecvEffectCount();
void RecvEffectResult();
void RecvStartMatch();
void RecvEndMatch();
void RecvInitTournament();
void RecvErrorCode();
void RecvJoinNumber();
void RecvLocalUserNotice();
void RecvAllUserData();
void RecvStartMatchNotice(void);
void RecvEndMatchNotice(void);
void RecvSyncRASAMatch(void);
void RecvCheckJoinerNum(void);
void RecvStatusMatchNotice(void);
void RecvNoticeBattle(void);
void RecvBuyBattleTicket(void);
void RecvTwoGyunTotalNak(void);
void RecvObserveStart(void);
void RecvObserveEnd(void);
void RecvObserveMatchTime(void);
void RecvMatchProgressTime(void);
void RecvPauseMatchNotice(void);
public :
void SendRequestStartBattle(int iManorIdx);
void SendRequestStartJoin();
void SendRequestCloseJoin();
void SendRequestStartBetting();
void SendRequestReadyTournament();
void SendRequestStartCount();
void SendRequestEndMatch();
void SendRequestWaitTournament();
void SendRequestCloseBattle();
void SendRequestStartPrize();
void SendRequestCancelTournament();
void SendAcceptTransGolryun();
void SendAcceptToBattle();
void SendBuyBattleTicket(int itemTableIdx, int number);
void SendReNewBattleTicket();
void SendReNewDisplayTournament();
void SendCheckStartMatch();
void SendCheckJoinerNum();
void SendTransWaitingRoom();
void SendTransWatchingRoom();
void SendTransBattleStadium();
void SendNoticeBattle(char* notice);
void SendWalkOverMatch(int joinNum);
void SendTwoGyunTotalNak(void);
void SendObserveEnd(void);
void SendOpenBattleTicket(void);
void SendOpenShareWin(void);
void SendDisplayTournament(void);
void SendRequestPauseMatch(void);
void SendRequestReStartMatch(void);
void SendInsertJoinList(char* name);
void SendAssignFighterNumber(char* name, int number);
void SendRequestStartReCallFighter(void);
};
struct tagGolryun_Packet_Status{
public:
enum{
GB_REQUEST_INIT_BATTLE = 0,
GB_REQUEST_START_BATTLE,
GB_REQUEST_START_JOIN,
GB_REQUEST_CLOSE_JOIN,
GB_REQUEST_START_BETTING,
GB_REQUEST_READY_TOURNAMENT,
GB_REQUEST_START_COUNT,
GB_REQUEST_PROGRESS_MATCH,
GB_REQUEST_END_MATCH,
GB_REQUEST_WAIT_TOURNAMENT,
GB_REQUEST_CLOSE_BATTLE,
GB_REQUEST_START_PRIZE,
GB_REQUEST_CANCEL_TOURNAMENT,
GB_TRANS_GOLRYUN,
GB_ACCEPT_TRANS_GOLRYUN,
GB_TRANS_ARAYAN,
GB_BUY_BATTLE_TICKET,
GB_RENEW_BATTLE_TICKET,
GB_RENEW_DISPLAY_TOURNAMENT,
GB_SUGGEST_BATTLE,
GB_ACCEPT_BATTLE,
GB_OPEN_BATTLE_TICKET,
GB_SHARE_RATE,
GB_OPEN_SHARE_WIN,
GB_DISPLAY_TOURNAMENT,
GB_CHECK_PRIZE,
GB_TIME_OVER,
GB_EFFECT_RESULT,
GB_CHECK_START_MATCH,
GB_ERROR_CODE,
GB_LOCAL_USER_NOTICE,
GB_ALL_USER_DATA,
GB_START_MATCH_NOTICE,
GB_END_MATCH_NOTICE,
GB_BATTLE_RASA_Sync,
GB_CHECK_JOINER_NUM,
GB_STATUS_MATCH_NOTICE,
GB_TRANS_WAITINGROOM,
GB_TRANS_WATCHINGROOM,
GB_TRANS_BATTLESTADIUM,
GB_NOTICE_BATTLE,
GB_WALKOVER_MATCH,
GB_TWOGYUN_TOTAL_NAK,
GB_OBSERVE_START,
GB_OBSERVE_END,
GB_OBSERVE_MATCH_TIME,
GB_MATCH_PROGRESS_TIME,
GB_PAUSE_MATCH,
GB_RESTART_MATCH,
GB_GM_NOTICE,
GB_INSERT_JOIN_LIST,
GB_ASSIGN_FIGHTER_NUMBER,
GB_START_RECALL_FIGHTER,
GB_FORCE_EJECT,
GB_CHECK_STATUS_PvPMODE,
};
};
struct tagGolryun_Packet_Error_Code{
public:
enum{
GB_ERROR_CODE_1 = 0,
GB_ERROR_CODE_2 ,
GB_ERROR_CODE_3 ,
GB_ERROR_CODE_4 ,
GB_ERROR_CODE_5 ,
GB_ERROR_CODE_6 ,
GB_ERROR_CODE_7 ,
GB_ERROR_CODE_8 ,
};
};
extern CGolryunBattle g_GolryunBattle;
#endif | C++ |
#include "../global_def.h"
CItemRecycleProc gItemRecycleProc;
extern CItemTableData gItemTableData;
CItemRecycleProc::CItemRecycleProc()
{
}
CItemRecycleProc::~CItemRecycleProc()
{
}
int CItemRecycleProc::RecycleProc(item_t *_item)
{
int itemTableIdx = _item->itemTableIdx;
int number = _item->durability + 1;
int level = _item->reqLevel;
char szTemp[256];
szTemp[0]='\0';
int UseItemType = gItemTableData.GetUseItemType(&g_itemTable[itemTableIdx]);
if(UseItemType == CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_QUESTSCROLL)
{
sprintf( szTemp, g_LPACK.GetMessage(0,947), _item->name );
g_ifMng->SetMessage( g_LPACK.GetMessage(0,322), szTemp );
return IF_CTL_NONE;
}
if(UseItemType == CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_RECYCLE)
{
char Temp[256];
Temp[0]='\0';
int LpackTab = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::LPACK_TAB);
int LpackIdx = gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::LPACK_INDEX);
if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_DURABILITY_MULTIPLY))
{
int iVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_DURABILITY_MULTIPLY);
sprintf( Temp, g_LPACK.GetMassage( LpackTab, LpackIdx ), iVal * number );
strcat(szTemp,Temp);
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_MULTIPLY))
{
int iVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_MULTIPLY);
sprintf( Temp, g_LPACK.GetMassage( LpackTab, LpackIdx ), 1 * level + iVal );
strcat(szTemp,Temp);
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_EXP_AND_GENEXP_MULTIPLY))
{
int iExpVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_EXP_MULTIPLY);
int iGenExpVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_LEVEL_GENEXP_MULTIPLY);
sprintf( Temp, g_LPACK.GetMassage( LpackTab, LpackIdx ), iExpVal * level , iGenExpVal * level );
strcat(szTemp,Temp);
}
else if(gItemTableData.IsType(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_PARAM_ITEM_FUNCTION))
{
int iVal= (int)gItemTableData.GetData(&g_itemTable[itemTableIdx],CItemTableData::ItemTable_FluxDataValue::RECYCLE_PARAM_ITEM_FUNCTION);
sprintf( Temp, g_LPACK.GetMassage( LpackTab, LpackIdx ), level * iVal);
strcat(szTemp,Temp);
}
}
else
{
int epackIdx = g_cgv.myCharacterInfo->equipment[EQUIP_EPACK];
if( epackIdx >= 0 && epackIdx < MAX_NUMBER_OF_OWNITEM )
{
int ePackItemTableIdx = g_cgv.myCharacterInfo->item[epackIdx].itemTableIdx;
if(ePackItemTableIdx >= 0 && ePackItemTableIdx < MAX_NUMBER_OF_ITEM_TABLE)
{
if(g_itemTable[ePackItemTableIdx].epkRecycleType == TypeItemTable_t::EPK_RECYCLE_TYPE_DISABLE)
{
sprintf( szTemp,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,403), g_cgv.myCharacterInfo->item[epackIdx].name );
g_ifMng->SetMessage( g_LPACK.GetMessage(0,322), szTemp );
return IF_CTL_NONE;
}
}
}
int sellCost, supplyRA, supplySA, onceRecoveryRA, onceRecoverySA;
int raCount, saCount;
sellCost = g_itemTable[itemTableIdx].sellCost;
onceRecoveryRA = g_cgv.myCharacterInfo->onceRecoveryRA;
onceRecoverySA = g_cgv.myCharacterInfo->onceRecoverySA;
supplyRA = g_itemTable[itemTableIdx].supplyRA;
supplySA = g_itemTable[itemTableIdx].supplySA;
int valueRa = (int)GetEpackRechargePrice_RA( onceRecoveryRA, 1.0f, (float)g_itemTable[itemTableIdx].level );
int valueSa = (int)GetEpackRechargePrice_SA( onceRecoverySA, 1.0f, (float)g_itemTable[itemTableIdx].level );
if( onceRecoveryRA > 0 )
raCount = sellCost * 3/10 * supplyRA * 0.01 / valueRa;
else
raCount = 0;
if( onceRecoverySA > 0 )
saCount = sellCost * 3/10 * supplySA * 0.01 / valueSa;
else
saCount = 0;
sprintf( szTemp, g_LPACK.GetMassage(0,135), _item->name, raCount, saCount );
}
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), szTemp, 0, IF_MESSAGE_EPACK_HOLE_ITEM );
return IF_CTL_NONE;
} | C++ |
#include "../global_def.h"
void GambleSystemDecode()
{
SHORT Packet = static_cast<enum enumGambleSystem>(MSG_ReadShort());
switch(Packet)
{
case BUY_GAMBLE_ITEM_REPLY:
GTH_ReplytMessage_BuyGambleItem();
break;
}
}
void GTH_ReplytMessage_BuyGambleItem()
{
int reply = 0;
int error = 0;
int inventoryPos = 0;
int itemIdx = 0;
int storeItemIdx = 0;
int curNumber = 0;
item_t item;
reply = MSG_ReadByte();
g_ifMng->m_storeWin->m_LockGambleStore = FALSE;
if( reply > 0 )
{
storeItemIdx = MSG_ReadShort();
curNumber = MSG_ReadShort();
MSG_ReadItem( &item );
int stackItemIdx = GTH_StackMyItem( &item );
int itemidx = g_ifMng->m_storeWin->m_curPage *
CGambleSystem::MAX_NUMBER_OF_STORE_DEFAULT_ITEM
+storeItemIdx;
for (int PageIdx = 0; PageIdx < g_ifMng->m_storeWin->m_curPage ;PageIdx++)
itemidx -= g_ifMng->m_storeWin->m_PageItemCount[PageIdx];
if ( itemidx >=0 || itemidx < MAX_NUMBER_OF_STORE_ITEM)
{
g_ifMng->m_storeWin->m_storeItem[itemidx].item.itemTableIdx = -1;
int FindItemIdx = GTH_GetInvenPosMatchMyItemTableIdx(CGambleSystem::LUCKY_STONE_ITEM_TABLE_IDX);
if ( FindItemIdx != -1 )
{
int price = g_ifMng->m_storeWin->m_storeItem[itemidx].price;
DeleteItemFromMyInventoryByInvenPos(FindItemIdx, price);
}
}
if( stackItemIdx >= 0 )
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += item.durability + 1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability + 1 >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
}
else
{
itemIdx = GTH_AddMyItem( &item );
inventoryPos = GTH_FindEmptyInventoryPos();
if ( inventoryPos != -1)
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
}
g_ifMng->m_storeWin->m_storeItem[storeItemIdx].curNumber = curNumber;
g_cgv.myCharacterInfo->curItemWeight = MSG_ReadShort();
}
else
{
error = MSG_ReadByte();
switch( error )
{
case ERROR_BUYITEM_1 :
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,36), 1, IF_MESSAGE_NONE );
break;
case ERROR_BUYITEM_2 :
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,48), 1, IF_MESSAGE_NONE );
break;
case ERROR_BUYITEM_3 :
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,49), 1, IF_MESSAGE_NONE );
break;
case ERROR_BUYITEM_5:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,35), 1, IF_MESSAGE_NONE );
break;
case ERROR_BUYITEM_6:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 530 ), 1, IF_MESSAGE_NONE );
break;
case ERROR_BUYITEM_7:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 531 ), 1, IF_MESSAGE_NONE );
break;
}
}
}
void GTH_SendMessageRequest_BuyGambleItem(int SlotIdx, int Num)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GAMBLE_SYSTEM );
MSG_WriteShort(&netMessage, BUY_GAMBLE_ITEM_REQUEST );
MSG_WriteLong(&netMessage, SlotIdx);
MSG_WriteLong(&netMessage, Num);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_SendMessage_GambleSystem_Active(BOOL bActive)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, GAMBLE_SYSTEM );
MSG_WriteShort(&netMessage, ACTIVE_SYSTEM_REQUEST );
MSG_WriteLong(&netMessage, bActive);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
} | C++ |
#include "../global_def.h"
void GTH_DecodeDanBattleSystem()
{
enumNewDanBattlePacket Packet = static_cast<enum enumNewDanBattlePacket>(MSG_ReadShort());
switch(Packet)
{
case CC_ACTIVE_SYSTEM:
GTH_ProcessMessage_DanBattleActiveSystem();
break;
case GSC_DAN_BATTLE_WIN_OPEN:
GTH_ProcessMessage_NewDanBattleWinOpen();
break;
case GSC_REQUEST_DANBATTLE:
GTH_ProcessMessage_RequestDanBattle();
break;
case GSC_SUGGEST_DANBATTLE:
GTH_ProcessMessage_SuggestDanBattle();
break;
case GSC_ACCEPT_DANBATTLE:
GTH_ProcessMessage_AcceptDanBattle();
break;
case GSC_DAN_BATTLE_READY:
GTH_ProcessMessage_NewDanBattleReady();
break;
case GSC_DAN_BATTLE_START:
GTH_ProcessMessage_NewDanBattleStart();
break;
case GSC_DAN_BATTLE_END:
GTH_ProcessMessage_NewDanBattleEnd();
break;
case GSC_DAN_BATTLE_RESULT:
GTH_ProcessMessage_DanBattleResult();
break;
case GSC_DAN_BATTLE_PLUNDER:
GTH_ProcessMessage_NewDanBattlePlunder();
break;
case GSC_DAN_BATTLE_INFO:
GTH_ProcessMessage_DanBattleInfo();
break;
case GSC_DAN_BATTLE_NOTICE_MSG:
GTH_ProcessMessage_DanBattleNoticeMsg();
break;
}
}
void GTH_ProcessMessage_DanBattleActiveSystem()
{
}
void GTH_ProcessMessage_RequestDanBattle()
{
BOOL Reply = FALSE;
tagGCPacket_NewDanBattle::enumCode code = tagGCPacket_NewDanBattle::enumCode::fail;
code = (tagGCPacket_NewDanBattle::enumCode)MSG_ReadLong();
if ( code == tagGCPacket_NewDanBattle::enumCode::success)
{
int Result = MSG_ReadByte();
if ( Result == 0)
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 652),
MSG_BUTTONTYPE_NONE, IF_MESSAGE_REQUEST_NEW_DANBATTLE, 1000.0f );
}
else
g_ifMng->ExitMessage();
return;
}
tagGCPacket_NewDanBattle::enumError erroridx = tagGCPacket_NewDanBattle::enumError::none;
erroridx = (tagGCPacket_NewDanBattle::enumError)MSG_ReadByte();
switch(erroridx)
{
case tagGCPacket_NewDanBattle::enumError::not_join_guild:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 599));
break;
case tagGCPacket_NewDanBattle::enumError::not_capacity:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 600));
break;
case tagGCPacket_NewDanBattle::enumError::not_enough_my_member:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 601));
break;
case tagGCPacket_NewDanBattle::enumError::nonexstent_guild:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 602));
break;
case tagGCPacket_NewDanBattle::enumError::myself_guild:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 603));
break;
case tagGCPacket_NewDanBattle::enumError::not_enough_target_member:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 604));
break;
case tagGCPacket_NewDanBattle::enumError::target_can_not_reciveMessage:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 605));
break;
case tagGCPacket_NewDanBattle::enumError::battleInsert_Error:
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 606));
break;
case tagGCPacket_NewDanBattle::enumError::not_Accept_DanBattle:
{
g_ifMng->ExitMessage();
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 607));
}
break;
case tagGCPacket_NewDanBattle::enumError::Error_Full_danbattleCount:
{
g_ifMng->ExitMessage();
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 665));
}break;
}
}
void GTH_ProcessMessage_AcceptDanBattle()
{
g_NewDanBattleSystem.InitDanBattleInfo();
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
if ( pDanBattleInfo == NULL)
return;
pDanBattleInfo->BattleMode = (NewDanBattleSystem::DanBattleInfo::enumBattleMode)MSG_ReadByte();
pDanBattleInfo->fRemainSec = MSG_ReadFloat();
pDanBattleInfo->nBattleMapIdx = MSG_ReadByte();
pDanBattleInfo->fWaitTImeForReady = MSG_ReadFloat();
pDanBattleInfo->fWaitTImeForEnd = MSG_ReadFloat();
pDanBattleInfo->RequestDanInfo.nDanIdx = MSG_ReadLong();
pDanBattleInfo->RequestDanInfo.nRemainPoint = MSG_ReadByte();
pDanBattleInfo->AcceptDanInfo.nDanIdx = MSG_ReadLong();
pDanBattleInfo->AcceptDanInfo.nRemainPoint = MSG_ReadByte();
pDanBattleInfo->fWaitTImeForReady = MSG_ReadFloat();
pDanBattleInfo->nDanBattleIdx = MSG_ReadLong();
g_NewDanBattleSystem.SetDanBattleStatus(
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY);
g_NewDanBattleSystem.m_EffectFlag = 0x00;
g_musicMng->ChangeBGMusic( "../BGMusic/danbattle.mp3" );
}
void GTH_SendMessage_DanBattleInfo()
{
}
void GTH_ProcessMessage_DanBattleResult()
{
char mSG[256];
char tempString[MAX_PATH];
char EnemyGuildName[GUILDNAMESTRING];
char NOTICE_String[MAX_PATH];
char* LoseGuildName;
CIFDanWarRequestWin* RequestWIn = g_ifMng->m_DanWarRequestWin;
tagGCPacket_NewDanBattle::enumwincode code = tagGCPacket_NewDanBattle::enumwincode::loss;
code = (tagGCPacket_NewDanBattle::enumwincode)MSG_ReadByte();
NewDanBattleSystem::DanBattleInfo::enumEndType type= (NewDanBattleSystem::DanBattleInfo::enumEndType)MSG_ReadLong();
_snprintf(EnemyGuildName, GUILDNAMESTRING, MSG_ReadString());
EnemyGuildName[GUILDNAMESTRING-1] = NULL;
switch (code )
{
case tagGCPacket_NewDanBattle::enumwincode::win:
{
sprintf(tempString, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 608));
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL, 156, g_pApp->m_myCharacter->position,NULL,
true, g_pApp->m_myCharacter->entityType, g_pApp->m_myCharacter->idxOnServer,
0.0f, 0.0f, 0.0f, -1.0f, false );
RequestWIn->m_textCtlDanName->SetText(g_cgv.syncCharacter[0].guildName);
RequestWIn->m_textCtlWorldName->SetText(EnemyGuildName);
LoseGuildName = EnemyGuildName;
}
break;
case tagGCPacket_NewDanBattle::enumwincode::loss:
{
sprintf(tempString, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 609));
RequestWIn->m_textCtlWorldName->SetText(g_cgv.syncCharacter[0].guildName);
LoseGuildName = g_cgv.syncCharacter[0].guildName;
RequestWIn->m_textCtlDanName->SetText(EnemyGuildName);
}break;
case tagGCPacket_NewDanBattle::enumwincode::draw:
{
sprintf(tempString, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 610));
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL, 156, g_pApp->m_myCharacter->position,NULL,
true, g_pApp->m_myCharacter->entityType, g_pApp->m_myCharacter->idxOnServer,
0.0f, 0.0f, 0.0f, -1.0f, false );
RequestWIn->m_textCtlWorldName->SetText(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 611));
RequestWIn->m_textCtlDanName->SetText(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 611));
}break;
}
strncpy(mSG, MSG_ReadString(), 256);
mSG[256-1] = NULL;
RequestWIn->m_ComboCtlDanWarType->ClearString();
RequestWIn->m_ComboCtlDanWarType->AddString(mSG);
RequestWIn->m_ComboCtlDanWarType->SetCurSel(0);
int WinCount = MSG_ReadLong();
int LoseCount = MSG_ReadLong();
_snprintf(mSG, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 612), WinCount, LoseCount );
mSG[256-1] = NULL;
RequestWIn->m_ComboCtlDanWarTime->ClearString();
RequestWIn->m_ComboCtlDanWarTime->AddString(mSG);
RequestWIn->m_ComboCtlDanWarTime->SetCurSel(0);
int MyPoint = MSG_ReadLong();
_snprintf(mSG, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 613), MyPoint);
mSG[256-1] = NULL;
RequestWIn->m_textCtlDanMemberNum->SetText(mSG);
g_ifMng->AddSysMessage( tempString, GTHCOLOR_ITEMNOTICE_MESSAGE);
switch(type)
{
case NewDanBattleSystem::DanBattleInfo::enumEndType::REMAIN_MEMBER_COUNT:
_snprintf(NOTICE_String, MAX_PATH, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 614), LoseGuildName);
break;
case NewDanBattleSystem::DanBattleInfo::enumEndType::TIME_OUT:
_snprintf(NOTICE_String, MAX_PATH, tempString);
break;
case NewDanBattleSystem::DanBattleInfo::enumEndType::SYSTEM:
_snprintf(NOTICE_String, MAX_PATH, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 616));
break;
}
NOTICE_String[MAX_PATH-1] = NULL;
g_NewDanBattleSystem.AddDanBattleNoticeMsg(NOTICE_String);
g_musicMng->ChangeBGMusic( g_pApp->m_mapInfos[ 0 ].BGMusic );
g_ifMng->m_DanWarBattleWin->Enable(FALSE);
g_ifMng->m_DanWarRequestWin->InitDanWarWin(CIFDanWarRequestWin::DanWarRequestWinType::RESULT,
&g_NewDanBattleSystem);
g_ifMng->m_DanWarRequestWin->Enable(TRUE);
g_ifMng->SetFocus(g_ifMng->m_DanWarRequestWin);
g_NewDanBattleSystem.InitDanBattleInfo();
}
void GTH_SendMessage_DanBattleResult()
{
}
void GTH_SendMessage_Request_NewDanBattleWinOpen()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DAN_BATTLE);
MSG_WriteShort(&netMessage, CC_DAN_BATTLE_WIN_OPEN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_NewDanBattleWinOpen()
{
tagGCPacket_NewDanBattle::enumCode code = tagGCPacket_NewDanBattle::enumCode::fail;
code = (tagGCPacket_NewDanBattle::enumCode)MSG_ReadLong();
if ( code == tagGCPacket_NewDanBattle::enumCode::fail)
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 617), 1, IF_MESSAGE_NONE );
return;
}
else
{
g_NewDanBattleSystem.InitDanBattleInfo();
g_NewDanBattleSystem.m_nMinPcCount = MSG_ReadByte();
g_NewDanBattleSystem.m_nBattleTimeForMin1 = MSG_ReadLong();
g_NewDanBattleSystem.m_nBattleTimeForMin2 = MSG_ReadLong();
NewDanBattleSystem::DanBattleInfo* pBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
if ( pBattleInfo != NULL)
pBattleInfo->nBattleMapIdx= MSG_ReadByte();
g_ifMng->m_DanWarRequestWin->InitDanWarWin(CIFDanWarRequestWin::DanWarRequestWinType::REQUEST,
&g_NewDanBattleSystem);
g_ifMng->m_DanWarRequestWin->Enable(TRUE);
g_ifMng->SetFocus(g_ifMng->m_DanWarRequestWin);
}
}
void GTH_ProcessMessage_NewDanBattleReady()
{
g_NewDanBattleSystem.InitDanBattleInfo();
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
int EnemyguildIdx = MSG_ReadLong();
_snprintf(pDanBattleInfo->RequestDanInfo.szGuildName, GUILDNAMESTRING, MSG_ReadString());
pDanBattleInfo->RequestDanInfo.szGuildName[GUILDNAMESTRING-1] = NULL;
int nMapIdx = MSG_ReadByte();
int nRemainTime = MSG_ReadLong();
pDanBattleInfo->fWaitTImeForReady = nRemainTime;
pDanBattleInfo->nBattleMapIdx = nMapIdx;
pDanBattleInfo->BattleMode = (NewDanBattleSystem::DanBattleInfo::enumBattleMode)MSG_ReadByte();
char worldname[WORLDNAMESTRING];
if ( nMapIdx >= 0 && nMapIdx < MAX_WORLD_NUMBER)
_snprintf(worldname,WORLDNAMESTRING, g_cgv.worldTable[nMapIdx].hanName);
worldname[WORLDNAMESTRING -1] = NULL;
char szDanBattleMode[50];
if ( pDanBattleInfo->BattleMode == NewDanBattleSystem::DanBattleInfo::enumBattleMode::BATTLEMODE_GENERAL)
{
strncpy(szDanBattleMode, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 618), 50);
}
else
strncpy(szDanBattleMode, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 619), 50);
szDanBattleMode[50-1] = NULL;
char msg[256];
_snprintf(msg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 620),
worldname,
pDanBattleInfo->RequestDanInfo.szGuildName,
nRemainTime/1000,
szDanBattleMode);
msg[256-1] = NULL;
g_ifMng->m_GmNotice = FALSE;
g_ifMng->AddSysMessage(msg, GTHCOLOR_ITEMNOTICE_MESSAGE);
g_NewDanBattleSystem.AddDanBattleNoticeMsg(msg, GTHCOLOR_ITEMNOTICE_MESSAGE);
g_NewDanBattleSystem.m_EffectFlag = 0x00;
g_NewDanBattleSystem.SetDanBattleStatus(
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY);
g_ifMng->m_GmNotice = FALSE;
g_NewDanBattleSystem.AddDanBattleNoticeMsg( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 621));
g_musicMng->ChangeBGMusic( "../BGMusic/danbattle.mp3" );
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( 43 ), GTH_SOUND_PLAY_ONCE );
}
void GTH_ProcessMessage_NewDanBattleStart()
{
int EnemyguildIdx = MSG_ReadLong();
int nMapIdx = MSG_ReadLong();
int nRemainTime = MSG_ReadLong();
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = NULL;
pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
if ( pDanBattleInfo != NULL)
pDanBattleInfo->fRemainSec = nRemainTime;
g_NewDanBattleSystem.m_EffectFlag = 0x00;
g_NewDanBattleSystem.SetDanBattleStatus(
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE);
g_ifMng->m_GmNotice = FALSE;
g_ifMng->AddSysMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 622), GTHCOLOR_ITEMNOTICE_MESSAGE);
g_NewDanBattleSystem.AddDanBattleNoticeMsg(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 622), GTHCOLOR_ITEMNOTICE_MESSAGE);
g_ifMng->m_DanWarBattleWin->Enable(TRUE);
g_ifMng->SetFocus(g_ifMng->m_DanWarBattleWin);
}
void GTH_ProcessMessage_NewDanBattleEnd()
{
int EnemyguildIdx = MSG_ReadLong();
int nMapIdx = MSG_ReadLong();
int nRemainTime = MSG_ReadLong();
g_NewDanBattleSystem.SetDanBattleStatus(
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_END);
g_NewDanBattleSystem.m_EffectFlag = 0x00;
g_ifMng->m_GmNotice = FALSE;
g_ifMng->AddSysMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 623), GTHCOLOR_ITEMNOTICE_MESSAGE);
g_ifMng->m_DanWarBattleWin->Enable(FALSE);
}
void GTH_ProcessMessage_NewDanBattlePlunder()
{
char Msg[tagGCPacket_NewDanBattle::msg_max_len+1];
tagGCPacket_NewDanBattle::PlunderPcCode PcCode
= (tagGCPacket_NewDanBattle::PlunderPcCode)MSG_ReadByte();
tagGCPacket_NewDanBattle::PlunderItemCode ItemCode
= (tagGCPacket_NewDanBattle::PlunderItemCode)MSG_ReadByte();
g_ifMng->m_GmNotice = FALSE;
if ( PcCode == tagGCPacket_NewDanBattle::PlunderPcCode::Attacker)
{
switch(ItemCode)
{
case tagGCPacket_NewDanBattle::PlunderItemCode::itemplunderFail:
{
g_ifMng->AddSysMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 624), GTHCOLOR_ITEMNOTICE_MESSAGE);
g_NewDanBattleSystem.AddDanBattleNoticeMsg( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 624), GTHCOLOR_ITEMNOTICE_MESSAGE );
break;
}
case tagGCPacket_NewDanBattle::PlunderItemCode::itemplunderSuccecs:
{
item_t Plunderitem;
MSG_ReadItem(&Plunderitem);
int stackItemIdx = GTH_StackMyItem( &Plunderitem );
if( stackItemIdx >= 0 )
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += Plunderitem.durability + 1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability + 1 >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
}
else
{
int itemIdx = GTH_AddMyItem( &Plunderitem );
int inventoryPos = GTH_FindEmptyInventoryPos();
if ( inventoryPos != -1)
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
}
_snprintf(Msg, tagGCPacket_NewDanBattle::msg_max_len,
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 625), Plunderitem.name);
Msg[tagGCPacket_NewDanBattle::msg_max_len] = NULL;
g_ifMng->m_GmNotice = FALSE;
g_ifMng->AddSysMessage(Msg, GTHCOLOR_ITEMNOTICE_MESSAGE);
g_NewDanBattleSystem.AddDanBattleNoticeMsg( Msg, GTHCOLOR_ITEMNOTICE_MESSAGE );
g_musicMng->PlaySample(g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_SUCCESS ), GTH_SOUND_PLAY_ONCE);
}
break;
case tagGCPacket_NewDanBattle::PlunderItemCode::NomoreitemPlunder:
g_ifMng->AddSysMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 626), GTHCOLOR_ITEMNOTICE_MESSAGE);
break;
}
}
else
{
if ( ItemCode == tagGCPacket_NewDanBattle::PlunderItemCode::itemDeleteSuccecs )
{
int DeleteInvenPos = MSG_ReadLong();
if ( DeleteInvenPos >= 0 && DeleteInvenPos < MAX_INVENTORY_SIZE)
{
int itemIdx = g_cgv.myCharacterInfo->inventory[DeleteInvenPos];
if ( itemIdx >= 0 && itemIdx < MAX_NUMBER_OF_OWNITEM )
{
item_t *pItem = NULL;
pItem = &g_cgv.myCharacterInfo->item[itemIdx];
_snprintf(Msg, tagGCPacket_NewDanBattle::msg_max_len,
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 627), pItem->name);
Msg[tagGCPacket_NewDanBattle::msg_max_len] = NULL;
}
DeleteItemFromMyInventoryByInvenPos(DeleteInvenPos);
}
g_ifMng->AddSysMessage(Msg, GTHCOLOR_ITEMNOTICE_MESSAGE);
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_BATTLE_FAIL ), GTH_SOUND_PLAY_ONCE );
}
}
}
void GTH_SendMessage_RequestDanBattle()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DAN_BATTLE);
MSG_WriteShort(&netMessage, CC_REQUEST_DANBATTLE);
MSG_WriteString(&netMessage, g_chatManager->GetInputStr( INPUT_INDEX_DAN_NAME ));
MSG_WriteByte(&netMessage, g_ifMng->m_DanWarRequestWin->m_ComboCtlDanWarType->GetCurSel());
MSG_WriteByte(&netMessage, g_ifMng->m_DanWarRequestWin->m_ComboCtlDanWarTime->GetCurSel());
MSG_WriteLong(&netMessage, g_ifMng->m_DanWarRequestWin->m_PrimiumItemCheckBox->GetCheck());
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_SuggestDanBattle()
{
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
if ( pDanBattleInfo == NULL)
return;
pDanBattleInfo->BattleMode = (NewDanBattleSystem::DanBattleInfo::enumBattleMode)MSG_ReadByte();
pDanBattleInfo->fRemainSec = MSG_ReadFloat();
pDanBattleInfo->RequestDanInfo.nDanIdx = MSG_ReadLong();
pDanBattleInfo->RequestDanInfo.nRemainPoint = MSG_ReadByte();
pDanBattleInfo->nBattleMapIdx = MSG_ReadByte();
_snprintf(pDanBattleInfo->RequestDanInfo.szGuildName, GUILDNAMESTRING, MSG_ReadString());
pDanBattleInfo->RequestDanInfo.szGuildName[GUILDNAMESTRING-1] = NULL;
pDanBattleInfo->bPlunderPremiumItem = MSG_ReadLong();
g_ifMng->m_DanWarRequestWin->InitDanWarWin(CIFDanWarRequestWin::DanWarRequestWinType::EXAMINATION,
&g_NewDanBattleSystem);
g_ifMng->m_DanWarRequestWin->Enable(TRUE);
g_ifMng->SetFocus(g_ifMng->m_DanWarRequestWin);
}
void GTH_SendMessage_ReplySuggest(tagGCPacket_NewDanBattle::enumCode code)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DAN_BATTLE);
MSG_WriteShort(&netMessage, CC_SUGGEST_DANBATTLE);
MSG_WriteByte(&netMessage, code);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_DanBattleInfo()
{
NewDanBattleSystem::DanBattleInfo* pDanBattleInfo = g_NewDanBattleSystem.GetDanBattleInfo();
pDanBattleInfo->BattleMode = (NewDanBattleSystem::DanBattleInfo::enumBattleMode)MSG_ReadByte();
pDanBattleInfo->BattleStatus = (NewDanBattleSystem::DanBattleInfo::enumBattleStatus)MSG_ReadByte();
pDanBattleInfo->nDanBattleIdx = MSG_ReadLong();
pDanBattleInfo->fRemainSec = MSG_ReadFloat();
pDanBattleInfo->nBattleMapIdx = MSG_ReadByte();
pDanBattleInfo->AcceptDanInfo.nDanIdx = MSG_ReadLong();
pDanBattleInfo->AcceptDanInfo.nRemainPoint = MSG_ReadByte();
pDanBattleInfo->AcceptDanInfo.nKillPoint = MSG_ReadLong();
pDanBattleInfo->AcceptDanInfo.naccumulationKillpoint = MSG_ReadLong();
g_cgv.myCharacterInfo->Killpoint = MSG_ReadLong();
g_cgv.myCharacterInfo->naccumulationKillpoint = MSG_ReadLong();
pDanBattleInfo->RequestDanInfo.nKillPoint = MSG_ReadLong();
pDanBattleInfo->RequestDanInfo.nRemainPoint = MSG_ReadByte();
pDanBattleInfo->RequestDanInfo.naccumulationKillpoint = MSG_ReadLong();
if ( pDanBattleInfo->BattleStatus != NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE)
return;
g_NewDanBattleSystem.SetDanBattleStatus(
NewDanBattleSystem::DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE);
g_musicMng->ChangeBGMusic( "../BGMusic/danbattle.mp3" );
g_ifMng->m_DanWarBattleWin->Enable(TRUE);
}
void GTH_SendMessage_ChangeStatus(NewDanBattleSystem::DanBattleInfo::enumBattleStatus status, char* guildname)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, NEW_DAN_BATTLE);
MSG_WriteShort(&netMessage, CS_DAN_BATTLE_CHANGE_STATUS);
MSG_WriteLong(&netMessage, status);
MSG_WriteString(&netMessage, guildname);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessage_DanBattleNoticeMsg()
{
NewDanBattleSystem::noticetype type = (NewDanBattleSystem::noticetype)MSG_ReadLong();
char Msg[256];
strncpy(Msg, MSG_ReadString(), 256);
Msg[255] = NULL;
DWORD color = GTHCOLOR_NOTICEMESSAGE;
switch(type)
{
case NewDanBattleSystem::noticetype::notice:
break;
case NewDanBattleSystem::noticetype::killpoint_notice:
color = GTHCOLOR_QUESTMESSAGE;
break;
case NewDanBattleSystem::noticetype::plunder_notice:
color = GTHCOLOR_LOOTMESSAGE;
break;
}
g_NewDanBattleSystem.AddDanBattleNoticeMsg(Msg, color, type);
} | C++ |
#ifndef _GAMBME_SYSTEM_
#define _GAMBME_SYSTEM_
#include <VECTOR>
class CGambleSystem
{
public:
enum
{
GOLD_ITEM_TABLE_IDX = 459,
LUCKY_STONE_ITEM_TABLE_IDX = 620,
QUESTION_MARK_ITEM_TABLE_IDX = 97,
MAX_REGSTER_ITEMCOUNT = 3,
GAMBLE_STORE_IDX = 23,
MAX_NUMBER_OF_STORE_DEFAULT_ITEM= 36,
};
private:
struct CollectGambleByType_t
{
enum AVAILABLE
{
OPTION_AVAILABLE_ON_DAGGER = 1,
OPTION_AVAILABLE_ON_1HSWORD,
OPTION_AVAILABLE_ON_2HSWORD,
OPTION_AVAILABLE_ON_BOW,
OPTION_AVAILABLE_ON_STAFF,
OPTION_AVAILABLE_ON_SPIRITOR,
OPTION_AVAILABLE_ON_CLAW,
OPTION_AVAILABLE_ON_ARMORS,
OPTION_AVAILABLE_ON_UPPER,
OPTION_AVAILABLE_ON_LOWER,
OPTION_AVAILABLE_ON_AIRPROTECTOR,
OPTION_AVAILABLE_ON_BODYPROTECTOR,
OPTION_AVAILABLE_ON_GLOVES,
OPTION_AVAILABLE_ON_BOOTS,
OPTION_AVAILABLE_ON_RING,
OPTION_AVAILABLE_ON_NECKLACE,
OPTION_AVAILABLE_ON_BRACELET,
OPTION_AVAILABLE_ON_EARRING,
OPTION_AVAILABLE_ON_EPACK,
OPTION_AVAILABLE_ON_ETC,
MAX_COUNT_OPTION_AVAILABLE_TYPE = 21,
};
struct GambleItem_t
{
int ItemIdx;
float GambleRate;
GambleItem_t()
{
ItemIdx = -1;
GambleRate = 0.0F;
};
};
int Type;
std::vector<int> vAvailableOption;
std::vector<GambleItem_t> vGambleItem;
float TotalGamebleRate;
CollectGambleByType_t();
};
public:
CGambleSystem();
~CGambleSystem();
};
#endif | C++ |
#include "../global_def.h"
int GTH_IsLock()
{
if( g_cgv.waitReply )
{
if( g_timer.GetAppMilliTime() - g_cgv.lastLockingTime > 5000.0f )
{
g_cgv.waitReply = false;
}
}
return( g_cgv.waitReply );
}
int GTH_LockSending()
{
if( GTH_IsLock() ) return false;
g_cgv.waitReply = true;
g_cgv.lastLockingTime = g_timer.GetAppMilliTime();
return( true );
}
void GTH_UnlockSending()
{
g_cgv.waitReply = false;
g_cgv.lastLockingTime = 0.0f;
}
#ifdef _TERRA
#include "..\Terra ICT\CTerraCtrl.h"
extern CTerraCtrl gcTerraCtrl;
#endif
int GTH_RenameList()
{
FILE *fp;
char source[256], target[256];
fp = fopen( "data/renlist.pack", "r" );
if( fp == NULL ) return( 0 );
while( 1 )
{
if( feof( fp ) )
{
break;
}
fscanf( fp, "%s %s", source, target );
while( !CopyFile( source, target, false ) )
{
Sleep( 500 );
}
remove( source );
}
fclose( fp );
remove( "data/renlist.pack" );
return( 1 );
}
int GTH_DeleteList()
{
FILE *fp;
char temp[255];
fp = fopen( "data/dellist.pack", "r" );
if( fp == NULL ) return( 0 );
while( 1 )
{
if( feof( fp ) )
{
break;
}
fscanf( fp, "%s", temp );
remove( temp );
}
fclose( fp );
remove( "data/dellist.pack" );
return( 1 );
}
void GTH_ServerShutdownTimer()
{
static int oldCountdown = 0;
int curTime, duration, countdown;
char msg[256];
if ( g_cgv.serverShutdownTimer.active )
{
curTime = g_timer.GetAppTime();
duration = curTime - g_cgv.serverShutdownTimer.setTime;
countdown = g_cgv.serverShutdownTimer.countdown - duration;
if ( countdown != oldCountdown)
{
oldCountdown = countdown;
if ( (countdown <= 10) || (countdown%10 == 0) )
{
sprintf(msg, g_LPACK.GetMassage(0,325), countdown);
g_ifMng->AddNoticeMessage( msg, D3DCOLOR_ARGB(255, 255, 55, 55) );
g_ifMng->AddSysMessage( msg, D3DCOLOR_ARGB(255, 255, 55, 55) );
g_musicMng->PlaySample(
g_soundMng->GetNormalSoundID( GTH_SOUND_ID_WARNING_2 ),
GTH_SOUND_PLAY_ONCE );
}
}
if (countdown <= 0)
{
GTH_SendMessage_DisconnectGameServer(FALSE);
g_cgv.serverShutdownTimer.isComplete = true;
g_cgv.serverShutdownTimer.active = false;
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,323), 1, IF_MESSAGE_EXIT_CLIENT );
}
}
}
void GTH_Init_ServerShutdownTimer()
{
g_cgv.serverShutdownTimer.setTime = 0;
g_cgv.serverShutdownTimer.active = false;
g_cgv.serverShutdownTimer.countdown = 0;
g_cgv.serverShutdownTimer.isComplete = false;
}
int GTH_GetTargetEntityForKeyMode( Fx_CHARACTER_t* pThisChar )
{
float distance;
int i, number;
Fx_CHARACTER_t *character;
character = &g_charManager->m_Characters[0];
number = g_charManager->m_iNumCharacters;
for (i=0; i<number; i++, character++)
{
if( character->entityType == ENTITY_PC || character->entityType == ENTITY_NPC ) continue;
if ( character->entityType == ENTITY_MONSTER )
{
if( character->stat_alive != MON_ALIVE_STATE_NORMAL ) continue;
}
if( character->flag_culled ) continue;
if( character->entityType == ENTITY_PC && character->idxOnServer == g_cgv.myPCIdxOnServer ) continue;
distance = GTH_GetDistance( pThisChar->position, character->position);
if ( distance < g_cgv.myCharacterInfo->calAttackLength )
{
g_cgv.pTargetChar = character;
return( true );
}
}
return( false );
}
int GTH_IsValidTargetAngleForKeyMode( Fx_CHARACTER_t* pThisChar )
{
Fx_CHARACTER_t* character;
int i;
vec3_t dir, angles;
if( pThisChar->targetType < 0 || pThisChar->targetIdx < 0 ) return( 0 );
character = &g_charManager->m_Characters[0];
for( i = 0; i < g_charManager->m_iNumCharacters; i ++, character ++ )
{
if( character->entityType == pThisChar->targetType && \
character->idxOnServer == pThisChar->targetIdx ) break;
}
if( i == g_charManager->m_iNumCharacters )
{
return( 0 );
}
VectorSubtract( dir, character->position, pThisChar->position );
dir[2] = 0.0f;
VectorNormalize( dir );
VectorToAngles( dir , angles );
if( abs( pThisChar->angles[YAW] - angles[ YAW ] ) < 90.0f ) return( 1 );
else return( 0 );
}
int GTH_CheckValidCharacterEvent( Fx_CHARACTER_t* character )
{
if( character->curRA <= 0 )
{
if( character->event == GTH_EV_CHAR_ATTACK || character->event == GTH_EV_CHAR_STUN ||
character->event == GTH_EV_CHAR_PC_STUN ||
character->event == GTH_EV_CHAR_FREEZE || character->event == GTH_EV_CHAR_PUSHED )
{
character->event = GTH_EV_CHAR_DIE;
return( 0 );
}
}
return( 1 );
}
int GTH_HaveWeapon( Fx_CHARACTER_t* character )
{
int itemIdx, mainClass;
if( character->equipNumber <= 0 ) return( 0 );
itemIdx = character->equipment[0];
if( itemIdx < 0 ) return( 0 );
mainClass = g_itemTable[itemIdx].classIdx;
if( g_itemClassTable[mainClass].attackAtt ) return( 1 );
return( 0 );
}
void GTH_GetRealMousePosition( vec3_t mousePos, vec3_t position )
{
vec3_t pos;
float dist;
dist = VectorDistance( mousePos, g_pApp->m_myCharacter->position );
dist -= g_cgv.mouseClickEventDistance;
if( g_cgv.clickEvent == GTH_CEV_CHAR_IDLE || g_cgv.clickEvent == GTH_CEV_CHAR_NONE )
{
VectorCopy( position, mousePos );
return;
}
else if( dist < 0.0f )
{
VectorCopy( position, g_pApp->m_myCharacter->position );
return;
}
VectorSubtract( pos, mousePos, g_pApp->m_myCharacter->position );
VectorNormalize( pos );
VectorScale( pos, pos, dist );
VectorAdd( position, pos, g_pApp->m_myCharacter->position );
}
void GTH_GetRealPosition( vec3_t position, float dist )
{
vec3_t pos;
float realDist;
realDist = VectorDistance( position, g_pApp->m_myCharacter->position );
if( dist > realDist ) return;
VectorSubtract( pos, position, g_pApp->m_myCharacter->position );
VectorNormalize( pos );
VectorScale( pos, pos, dist );
VectorAdd( position, pos, g_pApp->m_myCharacter->position );
}
int GTH_IsGameMaster( Fx_CHARACTER_t *character )
{
//lucky 2012 new GM system
if(character->gameMaster > 0)
{
return TRUE;
}
else
{
return FALSE;
}
//end
return( true );
}
int GTH_RenderGM( Fx_CHARACTER_t* character )
{
if( GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return( true );
else
{
if( GTH_IsGameMaster( character ) && character->stat_alive ) return( false );
}
return( true );
}
| C++ |
#include "../global_def.h"
CItemTableData gItemTableData;
CItemTableData::CItemTableData()
{
}
CItemTableData::~CItemTableData()
{
}
float CItemTableData::GetData(const int _ItemTableIndex ,const int _Type)
{
if(_ItemTableIndex < 0 && _ItemTableIndex >= MAX_NUMBER_OF_ITEM_TABLE)
{
return 0.0f;
}
itemTable_t * pItemTable = &g_itemTable[_ItemTableIndex];
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == pItemTable->iFluxDataIndex[i]) break;
if(pItemTable->iFluxDataIndex[i] == _Type)
{
return pItemTable->fFluxData[i];
}
}
return 0.0f;
}
float CItemTableData::GetData(const itemTable_t *_pItemTable,const int _Type)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(_pItemTable->iFluxDataIndex[i] == _Type)
{
return _pItemTable->fFluxData[i];
}
}
return 0.0f;
}
bool CItemTableData::IsType(const itemTable_t *_pItemTable,const int _Type)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(_pItemTable->iFluxDataIndex[i] == _Type)
{
return true;
}
}
return false;
}
int CItemTableData::GetUseItemType(const itemTable_t *_pItemTable)
{
for(int i=0;i<itemTable_t::MAX_ITEM_TABLE_FLOAT_DATA;i++)
{
if(0 == _pItemTable->iFluxDataIndex[i]) break;
if(0 < _pItemTable->iFluxDataIndex[i] && 100 > _pItemTable->iFluxDataIndex[i])
return _pItemTable->iFluxDataIndex[i];
}
return -1;
}
| C++ |
#ifndef _MANAGER_H_
#define _MANAGER_H_
#include <List>
using namespace std;
template<typename T>
class CManager
{
public:
typedef list<T*> ManagerList;
typedef ManagerList::iterator ManagerItor;
ManagerList m_GarbageList;
ManagerList m_ManagerList;
ManagerItor m_iLoop;
int m_PointerSize;
protected :
int InitializeGarbage(int GarbageCount,int GarbageSize);
public:
CManager();
virtual ~CManager();
int Create(int GrabageCount,int GarbageSize);
void Destroy();
T* GetFromGarbage();
void PushToManager(T* pVoid);
T* PopFromManager();
void PushToGarbage(T* pVoid);
T* FindData(int Pos);
T* FindDataName(T *rT);
void ClearList();
int GetManagerListCount( void ) { return m_ManagerList.size(); }
BOOL GetManagerListEmpty(void){return m_ManagerList.empty();}
};
template<typename T>
CManager<T>::CManager()
{
m_PointerSize=0;
}
template<typename T>
CManager<T>::~CManager()
{
Destroy();
}
template<typename T>
int CManager<T>::InitializeGarbage(int GarbageCount,int GarbageSize)
{
T* pTemp=NULL;
for (int i=0;i<GarbageCount;i++)
{
pTemp=new T;
if (!pTemp)
return FALSE;
m_GarbageList.push_back(pTemp);
}
return TRUE;
}
template<typename T>
inline
int CManager<T>::Create(int GarbageCount,int GarbageSize)
{
m_PointerSize=GarbageSize;
if (!InitializeGarbage(GarbageCount,GarbageSize))
return FALSE;
return TRUE;
}
template<typename T>
void CManager<T>::Destroy()
{
ManagerItor iLoop;
for( iLoop = m_ManagerList.begin(); iLoop != m_ManagerList.end(); iLoop++ )
{
delete (*iLoop);
}
for( iLoop = m_GarbageList.begin(); iLoop != m_GarbageList.end(); iLoop++ )
{
delete (*iLoop);
}
m_GarbageList.clear();
m_ManagerList.clear();
}
template<typename T>
inline
T* CManager<T>::GetFromGarbage()
{
T* pVoid=NULL;
if (m_GarbageList.empty())
{
pVoid=new T;
return pVoid;
}
ManagerItor itor = m_GarbageList.begin();
pVoid = (*itor);
m_GarbageList.pop_front();
return pVoid;
}
template<typename T>
inline
void CManager<T>::PushToManager(T* pVoid)
{
m_ManagerList.push_back(pVoid);
}
template<typename T>
inline
T* CManager<T>::PopFromManager()
{
T* pVoid=NULL;
if (m_ManagerList.empty())
{
return NULL;
}
ManagerItor itor = m_ManagerList.begin();
pVoid = (*itor);
m_ManagerList.pop_front();
return pVoid;
}
template<typename T>
inline
void CManager<T>::PushToGarbage(T* pVoid)
{
m_GarbageList.push_back(pVoid);
}
template<typename T>
T* CManager<T>::FindData(int Pos)
{
ManagerItor iLoop;
int LoopCount=0;
for( iLoop=m_ManagerList.begin();iLoop!=m_ManagerList.end();iLoop++ )
{
if (LoopCount==Pos)
{
return (*iLoop);
}
LoopCount++;
}
return NULL;
}
template<typename T>
T* CManager<T>::FindDataName(T *rT)
{
ManagerItor iLoop=NULL;
iLoop= find_if(m_ManagerList.begin(), m_ManagerList.end(),bind2nd(Tfind_if(),rT));
return (*iLoop) ;
}
template<typename T>
void CManager<T>::ClearList()
{
ManagerItor iLoop;
int LoopCount=0;
T* pVoid;
for (iLoop=m_ManagerList.begin();iLoop!=m_ManagerList.end();)
{
pVoid=(*iLoop);
m_ManagerList.erase(iLoop++);
PushToGarbage(pVoid);
}
}
#endif _MANAGER_H_
| C++ |
#if !defined(AFX_WEATHERSYSTEM_H__67AE6DCF_783D_4C64_B489_3E8CC40113F9__INCLUDED_)
#define AFX_WEATHERSYSTEM_H__67AE6DCF_783D_4C64_B489_3E8CC40113F9__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CWeatherSystem
{
public:
enum enumWeatherSystemProtocol
{
CC_WEATHER_SYSTEM_REQUEST_USE_WEATHER_ITEM,
GSC_WEATHER_SYSTEM_REPLY_USE_WEATHER_ITEM,
GSC_WEATHER_SYSTEM_REPLY_CURRENT_WEATHER,
CC_WEATHER_SYSTEM_REQUEST_WORLD_STATE,
GSC_WEATHER_SYSTEM_REQUEST_WORLD_STATE,
CC_WEATHER_SYSTEM_CHEAT_SETING,
CC_WEATHER_SYSTEM_NOTICE,
CC_WEATHER_SYSTEM_BROAD_CASTING_EVENT_SETING,
};
enum enumEventWorldState
{
WEATHER_SYSTEM_WORLD_PROGRESS,
WEATHER_SYSTEM_WORLD_NONE
};
enum enumWeatherSystemEventState
{
EVENT_INACTIVE,
EVENT_ACTIVE,
};
enum enumWeatherSystemEventError
{
ERROR_WEATHER_SYSTEM_USE_ITEM,
ERROR_WEATHER_SYSTEM_USE_ITEM2,
ERROR_WEATHER_SYSTEM_EQUIP_ITEM,
ERROR_WEATHER_SYSTEM_ACTIVE,
};
enum enumProgressLimitTime
{
SNOW_LITMIT_TIME = 60 * 5 * 1000,
RAIN_LITMIT_TIME = 60 * 5 * 1000,
DEFAULT_LIMIT_TIME = 60 * 5 * 1000,
};
private:
float m_Snow_LimitTime;
float m_Rain_LimitTime;
public:
void GTH_Process_Weather_System();
void GTH_ProcessMessage_Reply_WeatherSetting(void);
void GTH_SendMessage_Request_WeatherSetting
( TIMESTATE weather, float limittime = DEFAULT_LIMIT_TIME, bool IsUseItem = 0, int invenpos = -1 );
void GTH_ProcessMessage_WeatherSystemEvent();
void GTH_SendMessageEventSeting(int event);
void GTH_SendMessage_Request_WorldState(int worldidx);
void GTH_ProcessMessage_Request_WorldState();
void GTH_SendUserNotice(char *notice);
public:
void InitWeatherSystem();
public:
CWeatherSystem();
virtual ~CWeatherSystem();
};
#endif
| C++ |
#include "../global_def.h"
void CashMallItem_OptionStone::InitCashMallItem_OptionStone()
{
m_iEditOptionItemIdx = -1;
m_iUsingItemInvenIdx = -1;
m_iUsingItemMode = NONE_ITEM;
m_CashMallItem_DestroyRate = 0.0f;
m_CashMallItem_SuccecsRate = 0.0f;
memset(m_iSortOptionIdx, -1, MAX_NUMBER_OF_ITEM_OPTION);
}
| C++ |
#include "../global_def.h"
void CDanBattle::SendSetStatus(BYTE bStatus)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_SETSTATUS);
MSG_WriteByte(&netMessage, bStatus);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendRequestBattle()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_REQUEST_BATTLE );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendSuggestBattle(int danIdx,LPSTR pDanName)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_SUGGEST_BATTLE );
MSG_WriteLong(&netMessage, danIdx);
MSG_WriteString(&netMessage, pDanName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendSuggestResult(BYTE bResult)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_SUGGEST_RESULT);
MSG_WriteByte(&netMessage, bResult);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendChangeBattleMap()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_CHANGE_BATTLEMAP);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendCancelRequest()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_REQUEST_CANCEL);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendInitChao()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_INIT_CHAO);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::SendDanTestMode(int mode)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_BATTLE_TEST_MODE);
MSG_WriteByte(&netMessage, mode);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::RecvDanBattle()
{
BYTE bCommand;
bCommand = MSG_ReadByte();
switch (bCommand)
{
case DANB_ERROR : RecvErrorCode(); break;
case DANB_REQUESTER_LIST : RecvRequesterList(); break;
case DANB_SUGGEST_BATTLE : RecvSuggest(); break;
case DANB_BATTLE_INFO : RecvBattleInfo(); break;
case DANB_BATTLE_RESULT : RecvBattleResult(); break;
case DANB_BATTLE_READY : RecvBattleReady(); break;
case DANB_BATTLE_START : RecvBattleStart(); break;
case DANB_SUGGEST_RESULT : RecvSuggestResult(); break;
case DANB_BATTLE_DAN : RecvBattleDan(); break;
case DANB_BATTLE_REWARD : RecvBattleReward(); break;
case DANB_BATTLE_REFRESH_PERSONDATA
: RecvRefreshData(); break;
}
}
void CDanBattle::RecvErrorCode()
{
BYTE eCode = MSG_ReadByte();
BYTE eType = MSG_ReadByte();
}
void CDanBattle::RecvRequesterList()
{
BYTE bSize=MSG_ReadByte();
char tempMessage[MAX_PATH];
char DanName[GUILDNAMESTRING];
char UserName[NAMESTRING];
int danIdx;
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_guildArenaWin->Enable();
g_ifMng->SetFocus( g_ifMng->m_guildArenaWin );
g_ifMng->m_guildArenaWin->ClearStandbyList();
g_ifMng->m_guildArenaWin->m_StandByCount = bSize;
for (int i=0;i<bSize;i++)
{
danIdx=MSG_ReadLong();
sstrncpy(DanName,MSG_ReadString(),GUILDNAMESTRING-1);
sstrncpy(UserName,MSG_ReadString(),NAMESTRING-1);
if ( i == 0 )
strcpy(g_ifMng->m_guildArenaWin->m_szATeamList, DanName);
g_ifMng->m_guildArenaWin->m_szStandby_danIdx_List[i] = danIdx;
if ( danIdx == g_cgv.myCharacterInfo->guildIdx )
g_ifMng->m_guildArenaWin->m_MyTextIdxinStandby = i;
strcpy(g_ifMng->m_guildArenaWin->m_szStandbyList[i], DanName);
}
if ( bSize >= 2 )
{
if ( g_ifMng->m_guildArenaWin->m_szStandby_danIdx_List[0] ==
g_cgv.myCharacterInfo->guildIdx )
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_REQUEST;
else
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_NONE;
}
}
void CDanBattle::RecvBattleInfo()
{
int Point[2];
DWORD remainTime;
char tempMessage[MAX_PATH];
Point[0]=MSG_ReadLong();
Point[1]=MSG_ReadLong();
remainTime=MSG_ReadLong();
int totalUser=MSG_ReadLong();
int aliveUser=MSG_ReadLong();
g_ifMng->m_guildArenaInfoWin->m_AteamPoint = Point[0];
g_ifMng->m_guildArenaInfoWin->m_AJoinTotal = aliveUser;
totalUser=MSG_ReadLong();
aliveUser=MSG_ReadLong();
g_ifMng->m_guildArenaInfoWin->m_BteamPoint = Point[1];;
g_ifMng->m_guildArenaInfoWin->m_BJoinTotal = aliveUser;
Point[0]=MSG_ReadLong();
Point[1]=MSG_ReadLong();
g_ifMng->m_guildArenaInfoWin->m_AGuildTotal = Point[0];
g_ifMng->m_guildArenaInfoWin->m_BGuildTotal = Point[1];
g_ifMng->m_guildArenaInfoWin->SetBattleRemainTime(remainTime);
char DanName[2][GUILDNAMESTRING];
sstrncpy(DanName[0],MSG_ReadString(),GUILDNAMESTRING-1);
sstrncpy(DanName[1],MSG_ReadString(),GUILDNAMESTRING-1);
strcpy(g_ifMng->m_guildArenaInfoWin->m_AteamName, DanName[0]);
strcpy(g_ifMng->m_guildArenaInfoWin->m_BteamName, DanName[1]);
}
void CDanBattle::RecvBattleResult()
{
char szTemp[256];
BYTE bResult=MSG_ReadByte();
switch (bResult)
{
case 0 :
sprintf( szTemp, g_LPACK.GetMassage( 9, 57), g_ifMng->m_guildArenaInfoWin->m_AteamName);
g_ifMng->AddChatMessage( szTemp, GTHCOLOR_SYSMESSAGE, g_LPACK.GetMassage( 9, 45));
break;
case 1 :
sprintf( szTemp, g_LPACK.GetMassage( 9, 57), g_ifMng->m_guildArenaInfoWin->m_BteamName);
g_ifMng->AddChatMessage( szTemp, GTHCOLOR_SYSMESSAGE, g_LPACK.GetMassage( 9,45));
break;
case 2 :
g_ifMng->AddChatMessage( g_LPACK.GetMassage( 9,58), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMassage( 9,45));
break;
}
g_ifMng->m_guildArenaInfoWin->Enable(false);
g_ifMng->m_guildArenaWin->ClearRegTeams();
g_ifMng->m_miniMapWin->Enable();
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_NONE;
}
void CDanBattle::RecvBattleStart()
{
g_ifMng->AddChatMessage( g_LPACK.GetMassage(9, 62), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMassage(9, 67));
g_ifMng->m_guildArenaWin->Enable(false);
g_ifMng->m_guildArenaWin->ClearRegTeams();
g_ifMng->m_guildArenaInfoWin->Enable();
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_BATTLE;
g_ifMng->m_miniMapWin->Enable(false);
g_ifMng->SetFocus( g_ifMng->m_guildArenaInfoWin );
}
void CDanBattle::RecvSuggest()
{
g_ifMng->SetMessage( g_LPACK.GetMessage(0,322), g_LPACK.GetMessage(9,56), MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_DAN_BATTLE_SUGGEST_ACCEPT, 10000.0f );
}
void CDanBattle::RecvSuggestResult()
{
BYTE type = MSG_ReadByte();
if( g_ifMng->m_msgType == IF_MESSAGE_DAN_BATTLE_SUGGEST_ACCEPT )
g_ifMng->ExitMessage();
switch ( type )
{
case 0:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9,54), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_guildArenaWin->Enable(FALSE);
g_ifMng->m_guildArenaWin->ClearRegTeams();
break;
case 1:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(9,55), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_READY;
break;
case 2:
g_ifMng->AddSysMessage( g_LPACK.GetMessage(0, 36), D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_guildArenaWin->Enable(FALSE);
g_ifMng->m_guildArenaWin->ClearRegTeams();
break;
}
}
void CDanBattle::RecvBattleDan()
{
char tempString[MAX_PATH];
char DanName[2][GUILDNAMESTRING];
MSG_ReadLong();
MSG_ReadLong();
sstrncpy(DanName[0],MSG_ReadString(),GUILDNAMESTRING-1);
sstrncpy(DanName[1],MSG_ReadString(),GUILDNAMESTRING-1);
sprintf(tempString, g_LPACK.GetMassage(9, 63) ,DanName[0],DanName[1]);
g_ifMng->AddSysMessage( tempString, D3DCOLOR_ARGB(255, 255, 125, 100) );
}
void CDanBattle::RecvBattleReady()
{
g_ifMng->m_guildArenaWin->Enable(FALSE);
g_ifMng->m_guildArenaWin->ClearRegTeams();
g_ifMng->AddChatMessage( g_LPACK.GetMassage(9, 66), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMassage(9, 67));
g_ifMng->m_guildArenaInfoWin->SetBattleRemainTime(MSG_ReadLong());
}
void CDanBattle::SendBattleReady()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_DAN_BATTLE );
MSG_WriteByte(&netMessage, DANB_BATTLE_READY);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CDanBattle::RecvBattleReward()
{
int type=MSG_ReadLong();
int danFame=MSG_ReadLong();
int myFame=MSG_ReadLong();
int rankpoint=MSG_ReadLong();
char tempString[MAX_PATH];
if (type)
{
sprintf(tempString,
g_LPACK.GetMassage(9, 64),
danFame,myFame);
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
66,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
}
else
{
sprintf(tempString,
g_LPACK.GetMassage(9, 65),
danFame,myFame);
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
67,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
}
g_ifMng->AddSysMessage( tempString, D3DCOLOR_ARGB(255, 255, 125, 100) );
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = g_ifMng->m_guildArenaWin->STATE_NONE;
g_ifMng->m_guildArenaInfoWin->SetBattleRemainTime(0);
}
void CDanBattle::RecvRefreshData()
{
int type=MSG_ReadLong();
switch (type)
{
case 0:
{
int Nak=MSG_ReadLong();
g_cgv.myCharacterInfo->curChargeSE = Nak;
}
break;
case 1:
{
int rankpoint=MSG_ReadLong();
int famepoint=MSG_ReadLong();
g_cgv.myCharacterInfo->rankPoint = rankpoint;
g_cgv.myCharacterInfo->guild.famePoint = famepoint;
}
break;
case 2:
{
DWORD remaintime=MSG_ReadLong();
g_ifMng->m_guildArenaInfoWin->SetBattleRemainTime(remaintime);
}
break;
case 3:
int Danstate=MSG_ReadLong();
g_ifMng->m_guildArenaWin->m_ReadyBattleFlag = Danstate;
break;
}
} | C++ |
#if !defined(AFX_ITEMRECYCLEPROC_H__636A537B_5ADD_4274_B5E6_5AE6EA03FB32__INCLUDED_)
#define AFX_ITEMRECYCLEPROC_H__636A537B_5ADD_4274_B5E6_5AE6EA03FB32__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItemRecycleProc
{
public:
CItemRecycleProc();
virtual ~CItemRecycleProc();
public:
int RecycleProc(item_t *_item);
};
#endif
| C++ |
#if !defined(AFX_CHRISTMASEVENT_H__9C30DEFF_53FB_47D7_9913_165046629D93__INCLUDED_)
#define AFX_CHRISTMASEVENT_H__9C30DEFF_53FB_47D7_9913_165046629D93__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define CHRISTMASEVENT_LIMITTIME 300000
class CChristMasEvent
{
public:
enum enumChristMasProtocol
{
CC_CHRISTMAS_EVENT_REQUEST_USE_SNOWITEM,
GSC_CHRISTMAS_EVENT_REPLY_USE_SNOWITEM,
GSC_CHRISTMAS_EVENT_REPLY_CHRISTEVENT,
CC_CHRISTMAS_EVENT_REQUEST_EQUIPE_ITEM,
GSC_CHRISTMAS_EVENT_REPLY_EQUIPE_ITEM,
CC_CHRISTMAS_EVENT_SETING,
CC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE,
GSC_CHRISTMAS_EVENT_REQUEST_WORLD_STATE,
CC_CHRISTMAS_EVENT_NOTICE,
CC_CHRISTMAS_BROAD_CASTING_EVENT_SETING,
};
enum enumEventWorldState
{
CHRISTMAS_EVENT_WORLD_PROGRESS,
CHRISTMAS_EVENT_WORLD_NONE
};
enum enumChristMasEventState
{
EVENT_INACTIVE,
EVENT_ACTIVE,
};
enum enumChristMasEventError
{
ERROR_CHRISTMAS_EVENT_USE_ITEM,
ERROR_CHRISTMAS_EVENT_USE_ITEM2,
ERROR_CHRISTMAS_EVENT_EQUIP_ITEM,
ERROR_CHRISTMAS_EVENT_ACTIVE,
};
enumChristMasEventState m_EventState;
public:
void GTH_Process_ChristMas_Event();
void GTH_ProcessMessage_Reply_ChristMas_UseItem(void);
void GTH_SendMessage_Request_ChristMas_UseItem(int invenpos);
void GTH_ProcessMessage_ChristMasEvent();
void GTH_SendMessageEventSeting(int event);
void GTH_SendMessage_Request_WorldState(int worldidx);
void GTH_ProcessMessage_Request_WorldState();
void GTH_SendUserNotice(char *notice);
public:
void InitChristMasEvent();
public:
CChristMasEvent();
virtual ~CChristMasEvent();
};
#endif
| C++ |
#if !defined(AFX_IFHELPERWIN1_H__F690DEF0_1DFE_4451_AA11_4B48A517B910__INCLUDED_)
#define AFX_IFHELPERWIN1_H__F690DEF0_1DFE_4451_AA11_4B48A517B910__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "..\Game\HelperSystem.h"
enum
{
IT_HELPER_WIN_TITLE,
IT_HELPER_WIN_NAME,
IT_HELPER_WIN_LEVEL,
IT_HELPER_WIN_SPAWN_BTN,
IT_HELPER_WIN_DELETE_BTN,
IT_HELPER_WIN_SHUTDOWN_BTN,
NUM_IT_HELPER_WIN,
};
class CIFHelperWin : public CIFWindow
{
public:
CIFHelperWin(CIFControlNode *pParentControl = NULL);
virtual ~CIFHelperWin();
CIFText *m_textCtl[NUM_IT_HELPER_WIN];
CIFControl *m_titleBar;
CIFControl *m_titleBarBottom;
CIFButtonCtl *m_closeBtn;
CIFButtonCtl *m_SpawnBtn;
CIFButtonCtl *m_DeleteBtn;
CIFButtonCtl *m_ShutDownBtn;
CIFControl *m_onlineBar;
CIFControl *m_offlineBar;
CIFControl *m_nameLevelBar;
int m_Mode;
int m_selectedHelperIdx;
char m_selectedHelperName[NAMESTRING+1];
int m_totalOnlineHelperCount;
int m_totalHelperCount;
virtual void PrepareControl();
virtual void Render();
virtual int WindowFrame();
virtual int WindowProcess();
virtual int WindowSelection();
void AddHelper(HelperEntry* newHelper);
void RemoveHelper(char *HelperName);
void UpdateHelper(HelperEntry* oldHelper);
inline char* GetSelectedHelperName() { return m_selectedHelperName; }
};
#endif
| C++ |
#include "../global_def.h"
#include "..\Game\IFHelperWin.h"
#include "..\Game\HelperSystem.h"
CIFHelperWin::CIFHelperWin( CIFControlNode *pParentControl ) : CIFWindow( pParentControl )
{
for( int i = 0; i < NUM_IT_HELPER_WIN; i ++ )
m_textCtl[i] = new CIFText( this );
m_titleBar = new CIFControl( this );
m_titleBarBottom = new CIFControl( this );
m_closeBtn = new CIFButtonCtl( this );
m_SpawnBtn = new CIFButtonCtl(this);
m_DeleteBtn = new CIFButtonCtl(this);
m_ShutDownBtn = new CIFButtonCtl(this);
m_onlineBar = new CIFControl( this );
m_offlineBar = new CIFControl( this );
m_nameLevelBar = new CIFControl( this );
Enable( false );
g_ifMng->AddFocus( this );
SetWindowType( IF_HELPER_WINDOW_TYPE );
m_totalOnlineHelperCount = 0;
m_totalHelperCount = 0;
m_Mode = -1;
m_selectedHelperIdx = -1;
memset( m_selectedHelperName, 0, NAMESTRING );
m_SpawnBtn->Enable(FALSE);
}
CIFHelperWin::~CIFHelperWin() { }
void CIFHelperWin::PrepareControl()
{
CIFControl::PrepareControl( IF_HELPER_WIN );
m_textCtl[IT_HELPER_WIN_TITLE]->PrepareControl( IF_HELPER_WIN_TITLE_TEXT );
m_textCtl[IT_HELPER_WIN_NAME]->PrepareControl( IF_HELPER_WIN_NAME_TEXT );
m_textCtl[IT_HELPER_WIN_LEVEL]->PrepareControl( IF_HELPER_WIN_LEVEL_TEXT );
m_textCtl[IT_HELPER_WIN_SPAWN_BTN]->PrepareControl(IF_HELPER_WIN_SPAWN_TEXT);
m_textCtl[IT_HELPER_WIN_DELETE_BTN]->PrepareControl(IF_HELPER_WIN_DELETE_TEXT);
m_textCtl[IT_HELPER_WIN_SHUTDOWN_BTN]->PrepareControl(IF_HELPER_WIN_SHUTDOWN_TEXT);
m_titleBar->PrepareControl( IF_HELPER_WIN_TITLE_BAR );
m_titleBarBottom->PrepareControl( IF_HELPER_WIN_TITLE_BAR_BOTTOM );
m_closeBtn->PrepareControl( IF_HELPER_WIN_CLOSE_BTN_0 );
m_SpawnBtn->PrepareControl(IF_HELPER_WIN_SPAWN_BTN_0);
m_DeleteBtn->PrepareControl(IF_HELPER_WIN_DELETE_BTN_0);
m_ShutDownBtn->PrepareControl(IF_HELPER_WIN_SHUTDOWN_BTN_0);
m_onlineBar->PrepareControl( IF_HELPER_WIN_ONLINE_BAR );
m_offlineBar->PrepareControl( IF_HELPER_WIN_OFFLINE_BAR );
m_nameLevelBar->PrepareControl( IF_HELPER_WIN_NAMELEVEL_BAR );
}
void CIFHelperWin::Render()
{
if( !State() ) return;
g_ifMng->SetRenderState();
CIFControl::Render();
m_titleBar->Render();
m_titleBarBottom->Render();
m_closeBtn->Render();
m_SpawnBtn->Render();
m_DeleteBtn->Render();
m_ShutDownBtn->Render();
m_nameLevelBar->Render();
int i, idx = 1;
for( i = 0; i < MAX_TAKER_LIST; i ++ )
{
if( g_HelperSystem.m_HelperEntry[i].name[0] != 0 )
{
if( g_HelperSystem.m_HelperEntry[i].worldIdx == -1 || g_HelperSystem.m_HelperEntry[i].worldIdx == 255 )
{
m_offlineBar->m_info[0].clientY = m_textCtl[IT_HELPER_WIN_NAME]->GetYPos() + 15*idx;
m_offlineBar->UpdateBuffer();
m_offlineBar->Render();
}
else
{
m_onlineBar->m_info[0].clientY = m_textCtl[IT_HELPER_WIN_NAME]->GetYPos() + 15*idx;
m_onlineBar->UpdateBuffer();
m_onlineBar->Render();
}
idx++;
}
}
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->BeginFrame();
{
m_textCtl[IT_HELPER_WIN_TITLE]->Render();
m_textCtl[IT_HELPER_WIN_NAME]->Render();
m_textCtl[IT_HELPER_WIN_LEVEL]->Render();
m_textCtl[IT_HELPER_WIN_DELETE_BTN]->Render();
m_textCtl[IT_HELPER_WIN_SHUTDOWN_BTN]->Render();
char szTemp[32+1];
int x, y, xs, ys;
idx = 1;
y = m_textCtl[IT_HELPER_WIN_NAME]->GetYPos();
xs = m_textCtl[IT_HELPER_WIN_NAME]->GetXSize();
ys = m_textCtl[IT_HELPER_WIN_NAME]->GetYSize();
for( i = 0; i < MAX_TAKER_LIST; i ++ )
{
if( g_HelperSystem.m_HelperEntry[i].name[0] != 0 )
{
if( m_selectedHelperIdx == idx)
g_chatManager->SetColor( 0xff0000ff );
else
{
if(g_HelperSystem.m_HelperEntry[i].bDeleteMe == TRUE)
g_chatManager->SetColor(D3DCOLOR_ARGB(255, 255, 0, 0));
else
g_chatManager->SetColor( 0xffffffff );
}
x = m_textCtl[IT_HELPER_WIN_NAME]->GetXPos();
g_chatManager->DrawText( x, y + idx * 15, g_HelperSystem.m_HelperEntry[i].name );
if( g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
{
x = m_textCtl[IT_HELPER_WIN_LEVEL]->GetXPos();
_snprintf( szTemp, 32, "Lv.%d", g_HelperSystem.m_HelperEntry[i].level );
szTemp[32]=NULL;
g_chatManager->DrawText( x, y + idx * 15, szTemp );
}
idx++;
}
}
}
g_chatManager->EndFrame();
}
int CIFHelperWin::WindowFrame()
{
char szTemp[256+1];
if(m_Mode == 0)
{
_snprintf(szTemp, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,326));
szTemp[256]=NULL;
m_textCtl[IT_HELPER_WIN_TITLE]->SetText( szTemp );
_snprintf(szTemp, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,327), m_totalOnlineHelperCount, m_totalHelperCount);
szTemp[256]=NULL;
m_textCtl[IT_HELPER_WIN_NAME]->SetText( szTemp );
m_SpawnBtn->SetButtonState(IF_BTN_TYPE_ENABLE);
}
else
{
_snprintf(szTemp, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,328));
szTemp[256]=NULL;
m_textCtl[IT_HELPER_WIN_TITLE]->SetText( szTemp );
_snprintf(szTemp, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,329), m_totalOnlineHelperCount, m_totalHelperCount);
szTemp[256]=NULL;
m_textCtl[IT_HELPER_WIN_NAME]->SetText( szTemp );
m_SpawnBtn->SetButtonState(IF_BTN_TYPE_DISABLE);
}
_snprintf( szTemp, 256, "Lv" );
szTemp[256]=NULL;
m_textCtl[IT_HELPER_WIN_LEVEL]->SetText( szTemp );
m_textCtl[IT_HELPER_WIN_SPAWN_BTN]->SetText(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,301));
m_textCtl[IT_HELPER_WIN_DELETE_BTN]->SetText(g_LPACK.GetMassage(LPACK_TYPE_NORMAL,244));
m_textCtl[IT_HELPER_WIN_SHUTDOWN_BTN]->SetText(g_LPACK.GetMassage(LPACK_TYPE_NORMAL,936));
m_textCtl[IT_HELPER_WIN_NAME]->SetColor( 0xffffffff );
m_textCtl[IT_HELPER_WIN_LEVEL]->SetColor( 0xffffffff );
return( IF_CTL_NONE );
}
int CIFHelperWin::WindowProcess()
{
char szTemp[256+1];
if( m_closeBtn->ProcessButton() == IF_CTL_SELECT )
{
Enable( false );
return IF_CTL_SELECT;
}
if(m_ShutDownBtn->ProcessButton() == IF_CTL_SELECT)
{
Enable(false);
return IF_CTL_SELECT;
}
if(m_SpawnBtn->ProcessButton() == IF_CTL_SELECT)
{
g_HelperSystem.GTH_SendMessage_HelpSystem_SpawnTaker(m_selectedHelperName);
return IF_CTL_SELECT;
}
if(m_DeleteBtn->ProcessButton() == IF_CTL_SELECT)
{
g_HelperSystem.GTH_SendMessage_HelpSystem_RemovePlayer(m_selectedHelperName);
return IF_CTL_SELECT;
}
int mx, my;
int x1, y1, xs, ys, i, idx;
idx = 1;
x1 = m_textCtl[IT_HELPER_WIN_NAME]->GetXPos();
xs = m_textCtl[IT_HELPER_WIN_NAME]->GetXSize();
ys = m_textCtl[IT_HELPER_WIN_NAME]->GetYSize();
for( i=0; i < MAX_TAKER_LIST; i++ )
{
if( g_HelperSystem.m_HelperEntry[i].name[0] != '\0' )
{
y1 = m_textCtl[IT_HELPER_WIN_NAME]->GetYPos() + idx * 15;
mx = g_input->GetPosX();
my = g_input->GetPosY();
mx = mx - x1;
my = my - y1;
if( mx < 0 || my < 0 || mx > xs || my > ys )
{
}
else
{
if( g_input->GetLBDown() )
{
if( g_HelperSystem.m_HelperEntry[i].worldIdx >= 0)
{
m_selectedHelperIdx = idx;
strncpy( m_selectedHelperName, g_HelperSystem.m_HelperEntry[i].name, NAMESTRING);
m_selectedHelperName[NAMESTRING]=NULL;
}
}
if( g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
{
g_ifMng->InitRolloverText();
g_ifMng->AddRolloverText( g_LPACK.GetMessage( LPACK_TYPE_ETC, CLPack_Etc::LPACK_ETCTYPE_PC_JOB, g_HelperSystem.m_HelperEntry[i].job ) );
_snprintf( szTemp, 256, "(%s)", g_LPACK.GetMessage( 0, 723 ) );
if( g_HelperSystem.m_HelperEntry[i].worldIdx == -1 || g_HelperSystem.m_HelperEntry[i].worldIdx == 255 )
_snprintf( szTemp, 256, "(%s)", g_LPACK.GetMessage( 0, 723 ) );
else
_snprintf( szTemp, 256, "(%s)", g_cgv.worldTable[ g_HelperSystem.m_HelperEntry[i].worldIdx ].hanName );
szTemp[256]=NULL;
g_ifMng->AddRolloverText( szTemp );
g_ifMng->MakeRolloverText( g_input->GetPosX(), g_input->GetPosY(), true );
}
break;
}
idx++;
}
}
return IF_CTL_NONE;
}
int CIFHelperWin::WindowSelection()
{
int ret=-1;
ret = m_titleBar->Selection();
if( ret == IF_LBDN ) return( IF_CTL_BEGIN_MOVING );
ret = Selection();
if( ret == IF_LBDN ) return( IF_CTL_SELECT );
return( IF_CTL_NONE );
}
void CIFHelperWin::AddHelper(HelperEntry* newHelper)
{
for( int i=0; i < MAX_TAKER_LIST; i++ )
{
if(g_HelperSystem.m_HelperEntry[i].name[0] == 0)
{
g_HelperSystem.m_HelperEntry[i].job = newHelper->job;
g_HelperSystem.m_HelperEntry[i].level = newHelper->level;
strncpy(g_HelperSystem.m_HelperEntry[i].name, newHelper->name, NAMESTRING);
g_HelperSystem.m_HelperEntry[i].name[NAMESTRING]=NULL;
g_HelperSystem.m_HelperEntry[i].worldIdx = newHelper->worldIdx;
m_totalHelperCount++;
if(g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
{
m_totalOnlineHelperCount++;
}
break;
}
}
}
void CIFHelperWin::RemoveHelper(char *HelperName)
{
for( int i=0; i < MAX_TAKER_LIST; i++ )
{
if(g_HelperSystem.m_HelperEntry[i].name[0] != 0 )
{
if( strcmp(g_HelperSystem.m_HelperEntry[i].name, HelperName) == 0 )
{
g_HelperSystem.m_HelperEntry[i].job = 0;
g_HelperSystem.m_HelperEntry[i].level = 0;
memset(g_HelperSystem.m_HelperEntry[i].name, 0, NAMESTRING );
if(g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
m_totalOnlineHelperCount--;
g_HelperSystem.m_HelperEntry[i].worldIdx = -1;
m_totalHelperCount--;
break;
}
}
}
}
void CIFHelperWin::UpdateHelper(HelperEntry* oldHelper)
{
for( int i=0; i< MAX_TAKER_LIST; i++ )
{
if(g_HelperSystem.m_HelperEntry[i].name[0] != 0 )
{
if( strcmp(g_HelperSystem.m_HelperEntry[i].name, oldHelper->name) == 0 )
{
g_HelperSystem.m_HelperEntry[i].job = oldHelper->job;
g_HelperSystem.m_HelperEntry[i].level = oldHelper->level;
strncpy(g_HelperSystem.m_HelperEntry[i].name, oldHelper->name, NAMESTRING);
g_HelperSystem.m_HelperEntry[i].name[NAMESTRING] = NULL;
if(g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
{
if( oldHelper->worldIdx == -1 || oldHelper->worldIdx == 255 )
m_totalOnlineHelperCount--;
}
else
{
if( oldHelper->worldIdx != -1 && oldHelper->worldIdx != 255 )
m_totalOnlineHelperCount++;
}
g_HelperSystem.m_HelperEntry[i].worldIdx = oldHelper->worldIdx;
break;
}
}
}
}
| C++ |
#include "../global_def.h"
globalVariable_t g_cgv;
void GTH_InitClientGlobalVariable()
{
g_cgv.state = CLIENT_START_PROCESS;
g_cgv.onMasterServer = false;
g_cgv.onGameServer = false;
g_cgv.displayDebugMessage = 0;
g_cgv.enableChat = false;
g_cgv.chatColor = 0xffffffff;
g_cgv.whisperType = 0;
g_cgv.myCharacterInfo = &g_cgv.savedData[0];
g_cgv.flagChangeWorld = false;
g_cgv.offLineStartFlag = false;
g_cgv.processChangeType = true;
g_cgv.clickEvent = GTH_CEV_CHAR_NONE;
GTH_InitSavedData();
g_cgv.inputMode = CLIENT_INPUT_MOUSE_MODE;
g_cgv.resendFlag = false;
g_cgv.enablePK = false;
g_cgv.isReceiveAllSavedData = false;
g_cgv.resendTargeting = false;
VectorClear( g_cgv.oldTargetPosition );
g_cgv.targetItemIdxOnServer = -1;
g_cgv.epackRADelayTime = 0.0f;
g_cgv.epackSADelayTime = 0.0f;
GTH_UnlockSending();
g_cgv.resendAttack = false;
g_cgv.saveEvent = -1;
g_cgv.sendSkillFlag = false;
memset( g_cgv.targetName, 0, NAMESTRING );
g_cgv.callGMTimer = 0;
for( int i = 0; i < 20; i ++ )
{
memset( g_cgv.callerName[i], 0, sizeof( chatMessage ) );
}
g_cgv.isGmBusy = false;
g_cgv.isGmHide = false;
g_cgv.summonMonsterIdx = 0;
g_cgv.summonAiType = 2;
g_cgv.summonValidTime = -1.0f;
g_cgv.saveMenuTime = -1.0f;
g_cgv.restartState = RESTART_NONE;
g_cgv.savedDataNumber = 0;
g_cgv.currentSyncTime = -1.0f;
g_cgv.lastSyncTime = -1.0f;
g_cgv.minSyncTime = 10000.0f;
g_cgv.maxSyncTime = 0.0f;
g_cgv.missSyncTimeCount = 0;
memset( g_cgv.syncTimeList, 0, sizeof(g_cgv.syncTimeList) );
g_cgv.syncSampleCount = 0;
g_cgv.syncAverage = 0.0f;
g_cgv.syncOverAverageCount = 0;
g_cgv.myCharacterInfo->m_bChatBan_Flag=false;
g_cgv.myCharacterInfo->m_dwLimite_ChatTime=0.0f;
g_cgv.myCharacterInfo->itemDivideType=0;
g_cgv.myCharacterInfo->m_bischange=false;
g_cgv.myCharacterInfo->m_bbattleMode=FALSE;
g_cgv.m_fClientGameVersion =1.16f;
g_cgv.Skill.iRecvSkillCastingCount=-1;
g_cgv.Skill.iSkillExecuteIndex=-1;
g_cgv.Skill.iSkillExecuteTargetType=0;
g_cgv.Skill.iSkillExecuteUseType=0;
g_cgv.Skill.iSelectSkillUseType=0;
g_cgv.Skill.iSelectSkillTableIdx=-1;
g_cgv.Skill.iUseInvenPos=0;
g_cgv.characterSlotMode = globalVariable_t::CharacterSlotMode::FRONT;
}
int GTH_InputState()
{
return( g_cgv.inputMode );
}
void GTH_InitSavedData()
{
int i, j, k;
for( i = 0; i < MAX_SAVED_DATA; i ++ )
{
memset( &g_cgv.savedData[i], 0, sizeof( myCharacterInfo_t ) );
g_cgv.savedData[i].m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_cgv.savedData[i].characterID = -1;
g_cgv.savedData[i].targetIdx = -1;
for( j = 0; j < MAX_INVENTORY_SIZE; j ++ )
g_cgv.savedData[i].inventory[j] = -1;
for( j = 0; j < MAX_DEPOT_SIZE; j ++ )
g_cgv.savedData[i].depot[j] = -1;
for( j = 0; j < MAX_EQUIPMENT; j ++ )
g_cgv.savedData[i].equipment[j] = -1;
for( j = 0; j < MAX_PRECOCITY_SIZE; j ++ )
g_cgv.savedData[i].precocityInventory[j] = -1;
for( j = 0; j < MAX_BOOTH_INVENTORY_SIZE; j ++ )
g_cgv.savedData[i].boothInventory[j].itemIdx = -1;
for( j = 0; j < MAX_UPGRADE_SOURCE_ITEM_SIZE; j ++ )
g_cgv.savedData[i].upgradeSourceInventory[j] = -1;
for( j = 0; j < MAX_CRAFT_SOURCE_ITEM_SIZE; j ++ )
g_cgv.savedData[i].craftSourceInventory[j] = -1;
for( j = 0; j < MAX_TRADE_SIZE; j ++ )
g_GonryunBattlePractic.m_imyTradetemp[j] = -1;
g_cgv.savedData[i].mouseInventory = -1;
for (j = 0; j < MAX_NUMBER_OF_OWNITEM; j++)
{
g_cgv.savedData[i].item[j].itemTableIdx = -1;
for (k=0; k<MAX_NUMBER_OF_ITEM_OPTION; k++)
{
g_cgv.savedData[i].item[j].optionIdx[k] = -1;
}
}
for( j = 0; j < MAX_TRADE_SIZE; j ++ )
{
g_cgv.savedData[i].myTrade[j] = -1;
g_cgv.savedData[i].otherTrade[j] = -1;
g_cgv.savedData[i].tradeItem[j].itemTableIdx = -1;
for (k=0; k<MAX_NUMBER_OF_ITEM_OPTION; k++)
{
g_cgv.savedData[i].tradeItem[j].optionIdx[k] = -1;
}
}
memset( &g_cgv.savedData[i].organizerName, 0, sizeof( g_cgv.savedData[i].organizerName ) );
g_cgv.savedData[i].organizeServer = -1;
g_cgv.savedData[i].organizeTime = -1;
g_cgv.savedData[i].partyIndex = -1;
g_cgv.savedData[i].memberNumber = 0;
g_cgv.savedData[i].itemDivideType = 0;
g_cgv.savedData[i].m_bischange = false;
g_cgv.savedData[i].canJoin = true;
g_cgv.savedData[i].isLeader = false;
for( j = 0; j < MAX_NUMBER_OF_PARTY_MEMBER; j ++ )
{
memset( &g_cgv.savedData[i].member[j], 0, sizeof( partyMember_t ) );
g_cgv.savedData[i].member[j].serverIndex = -1;
}
g_cgv.savedData[i].skillNumber = 0;
for( j = 0; j < MAX_NUMBER_OF_SKILL; j ++ )
{
g_cgv.savedData[i].skill[j].idx = j;
g_cgv.savedData[i].skill[j].tableIdx = -1;
g_cgv.savedData[i].skill[j].iLevel = 0;
g_cgv.savedData[i].skillCurCooltime[j] = 0.0f;
g_cgv.savedData[i].skillMaxCooltime[j] = 0.0f;
}
g_cgv.savedData[i].skillCastingtime = 0.0f;
g_cgv.savedData[i].skillCastingState = true;
for (j=0; j<MAX_NUMBER_OF_SKILL_VARIABLE; j++)
g_cgv.savedData[i].skillVariable[j] = -1;
for( j = 0; j < MAX_AFFECT; j ++ )
{
memset( &g_cgv.savedData[i].affect[j], 0, sizeof( affect_t ) );
g_cgv.savedData[i].affect[j].type = -1;
}
g_cgv.savedData[i].targetingType = TARGETING_NORMAL;
}
}
void GTH_EnableMove()
{
g_cgv.characterMoveFlag = true;
}
int GTH_CheckMoveable()
{
return( 1 );
}
void GTH_DisableMove()
{
g_cgv.characterMoveFlag = false;
#ifdef _GTH_ONLINE_VERSION
g_pApp->m_myCharacter->targetIdx = -1;
g_pApp->m_myCharacter->targetType = -1;
#endif
g_cgv.pTargetChar = NULL;
}
int GTH_CanMove()
{
if( g_ifMng->CheckConditionalWindow() ) return 0;
if( g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_STAND ||
g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_SIT ||
g_pApp->m_myCharacter->event == GTH_EV_CHAR_SIT ||
g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_SKILLCASTING ||
g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_CASTINGIDLE ||
g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_SOCIAL_SHOUT ||
g_pApp->m_myCharacter->ani_curSetID == ANIM_ITEM_SOCIAL_BOW ||
g_pApp->m_myCharacter->ani_curSetType == ANIMTYPE_BYSKILL) return 0;
if( g_input->GetMouseMode() == INPUT_MOUSE_INTERFACE_MODE ) return 0;
return 1;
}
int GTH_SaveOptionToFile()
{
FILE *file;
char *buffer;
int size, ret;
file = fopen( "..\\optionconfig.cfg", "wb" );
if( file == NULL )
{
return 0;
}
buffer = (char *)&g_ifMng->m_dlgWin->m_checkViewType[0][0];
size = sizeof( g_ifMng->m_dlgWin->m_checkViewType );
ret = fwrite( buffer, size, 1, file );
g_ifMng->m_settingWin->GetOptionSet();
buffer = (char *)&g_ifMng->m_settingWin->m_optionSetInfo;
size = sizeof( g_ifMng->m_settingWin->m_optionSetInfo );
ret = fwrite( buffer, size, 1, file );
fclose( file );
return 1;
}
int GTH_LoadOptionFromFile()
{
FILE *file;
char buffer[128];
int size, ret;
memset( buffer, 0, sizeof( buffer ) );
file = fopen( "..\\optionconfig.cfg", "rb" );
if( file == NULL )
{
return 0;
}
size = sizeof( g_ifMng->m_dlgWin->m_checkViewType );
ret = fread( buffer, size, 1, file );
if( ret == 1 )
{
memcpy( &g_ifMng->m_dlgWin->m_checkViewType[0][0], buffer, size );
}
size = sizeof( g_ifMng->m_settingWin->m_optionSetInfo );
ret = fread( buffer, size, 1, file );
if( ret == 1 )
{
memcpy( &g_ifMng->m_settingWin->m_optionSetInfo, buffer, size );
g_ifMng->m_settingWin->SetOptionSet();
}
fclose( file );
return 1;
}
int GTH_CanOpenBooth()
{
if( g_ifMng->CheckConditionalWindow() ) return 0;
if ( (g_pApp->m_myCharacter->ani_curSetID != ANIM_ITEM_SIT) &&
(g_pApp->m_myCharacter->event != GTH_EV_CHAR_SIT) )
return 0;
return 1;
} | C++ |
#if !defined(AFX_NEWDANBATTLESYSTEM_H__12E6C569_671E_44EE_93DD_EE548AC47392__INCLUDED_)
#define AFX_NEWDANBATTLESYSTEM_H__12E6C569_671E_44EE_93DD_EE548AC47392__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif _MSC_VER > 1000
class NewDanBattleSystem
{
public:
struct DanBaseInfo
{
int nDanIdx;
char szGuildName[GUILDNAMESTRING];
int nKillPoint;
int naccumulationKillpoint;
int nRemainPoint;
};
struct DanBattleInfo
{
enum enumBattleMode
{
BATTLEMODE_FRIENDSHIP,
BATTLEMODE_GENERAL,
};
enum enumBattleStatus
{
BATTLESTATUS_NONE,
BATTLESTATUS_REGIST,
BATTLESTATUS_READY,
BATTLESTATUS_BATTLE,
BATTLESTATUS_END,
};
enum enumEndType
{
REMAIN_MEMBER_COUNT =0,
TIME_OUT,
SYSTEM,
};
enum enumBattleMode BattleMode;
enum enumBattleStatus BattleStatus;
struct DanBaseInfo RequestDanInfo;
struct DanBaseInfo AcceptDanInfo;
float fRemainSec;
int nBattleMapIdx;
float fItemDropRate;
int nDanBattleIdx;
float fWaitTImeForReady;
float fWaitTImeForEnd;
BOOL bPlunderPremiumItem;
};
struct sNoticeMsg{
float m_noticeTime;
char m_noticeMsg[256];
DWORD m_noticeColor;
};
enum noticetype
{
notice = 0,
killpoint_notice,
plunder_notice,
max_notice,
};
sNoticeMsg m_notice[noticetype::max_notice];
public:
BOOL m_bActive;
int m_nMinPcCount;
int m_nBattleTimeForMin1;
int m_nBattleTimeForMin2;
float m_fItemDropRate;
INT m_EffectFlag;
public:
void RenderDanBattle_Notice();
void AddDanBattleNoticeMsg(char* message, DWORD color = GTHCOLOR_ITEMNOTICE_MESSAGE, noticetype type = noticetype::notice);
protected:
DanBattleInfo m_DanBattleInfo;
public:
void InitDanBattleInfo();
DanBaseInfo* GetMyDanBattleInfo();
DanBaseInfo* GetDestDanBattleInfo();
DanBaseInfo* GetRequestDanBattleInfo();
DanBaseInfo* GetAcceptDanBattleInfo();
DanBattleInfo* GetDanBattleInfo();
void ShoeEffectCount(INT RemainTime);
void SetDanBattleStatus(DanBattleInfo::enumBattleStatus status);
BOOL IsDanBattleEnemy(int pcidx);
vector<int> v_EffectPC;
public:
void Update();
void BattleReady();
void Battle();
void BattleEnd();
public:
NewDanBattleSystem();
virtual ~NewDanBattleSystem();
};
#endif
| C++ |
#ifndef _DAN_H_
#define _DAN_H_
#define DAN_BATTLEMAP_NUM 20
typedef struct BATTLE_RECORD
{
int No;
}*LPBATTLE_RECORD;
typedef struct REQUEST_RECORD
{
int No;
int ServerNo;
int ServerID;
char DanName[GUILDNAMESTRING];
char MasterName[NAMESTRING];
int danMemberNumber;
int danBattleJoinNumber;
int KillNumber;
}*LPREQUEST_RECORD;
class CDanBattle
{
public :
CDanBattle(){}
~CDanBattle(){}
public :
void RecvDanBattle();
public :
void RecvErrorCode();
void RecvRequesterList();
void RecvSuggest();
void RecvBattleInfo();
void RecvBattleResult();
void RecvBattleStart();
void RecvSuggestResult();
void RecvBattleDan();
void RecvBattleReward();
void RecvRefreshData();
public :
void SendRequestBattle();
void SendSetStatus(BYTE bStatus);
void SendSuggestBattle(int danIdx,LPSTR DanName);
void SendSuggestResult(BYTE bResult);
void SendChangeBattleMap();
void SendInitChao();
void SendCancelRequest();
void SendBattleReady();
void RecvBattleReady();
void SendDanTestMode(int mode);
};
#endif | C++ |
#include "../global_def.h"
extern CItemTableData gItemTableData;
CWeatherSystem::CWeatherSystem()
{
}
CWeatherSystem::~CWeatherSystem()
{
}
void CWeatherSystem::InitWeatherSystem()
{
}
void CWeatherSystem::GTH_Process_Weather_System()
{
enum enumExtendSecondPacket_WeaterSystem SecondPackaetGroup;
SecondPackaetGroup = static_cast<enum enumExtendSecondPacket_WeaterSystem>(MSG_ReadShort());
if ( SecondPackaetGroup != GSC_WEATHER_SYSTEM )
return;
int type = MSG_ReadByte();
switch(type)
{
case GSC_WEATHER_SYSTEM_REPLY_USE_WEATHER_ITEM:
GTH_ProcessMessage_Reply_WeatherSetting();
break;
case GSC_WEATHER_SYSTEM_REPLY_CURRENT_WEATHER:
GTH_ProcessMessage_WeatherSystemEvent();
break;
case GSC_WEATHER_SYSTEM_REQUEST_WORLD_STATE:
GTH_ProcessMessage_Request_WorldState();
break;
default:
return;
}
}
void CWeatherSystem::GTH_ProcessMessage_Reply_WeatherSetting(void)
{
char str[MAX_PATH+1];
GTH_UnlockSending();
int reply = 1;
int error = 1;
reply = MSG_ReadLong();
if ( reply == 1 )
{
int invenPos;
int itemIdx;
item_t *item = NULL;
invenPos = MSG_ReadByte();
if ( invenPos < 0 )
goto error;
itemIdx = g_cgv.myCharacterInfo->inventory[invenPos];
if ( itemIdx < 0 )
goto error;
item = &g_cgv.myCharacterInfo->item[itemIdx];
if ( item == NULL)
goto error;
if( item->durability > 0 )
{
item->durability --;
}
else
{
GTH_DeleteMyItem( &g_cgv.myCharacterInfo->item[itemIdx] );
g_cgv.myCharacterInfo->inventory[invenPos] = -1;
}
int lpackTab = LPACK_TYPE_NORMAL2;
int lpackidx = 247;
if(item->itemTableIdx >= 0 && item->itemTableIdx < MAX_NUMBER_OF_ITEM_TABLE)
{
if(gItemTableData.IsType(&g_itemTable[item->itemTableIdx],CItemTableData::ItemTable_FluxDataType::USE_ITEM_FOR_WEATHER_RAIN))
{
lpackTab = gItemTableData.GetData(&g_itemTable[item->itemTableIdx],CItemTableData::ItemTable_FluxDataValue::LPACK_TAB);
lpackidx = gItemTableData.GetData(&g_itemTable[item->itemTableIdx],CItemTableData::ItemTable_FluxDataValue::LPACK_INDEX);
}
}
sprintf(str, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, lpackidx), g_cgv.myCharacterInfo->name,
g_cgv.worldTable[g_cgv.syncCharacter[0].worldIdx].hanName);
str[MAX_PATH] = NULL;
GTH_SendUserNotice(str);
return;
}
else
{
error = MSG_ReadLong();
switch(error)
{
case ERROR_WEATHER_SYSTEM_USE_ITEM:
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL, 395));
}
break;
case ERROR_WEATHER_SYSTEM_USE_ITEM2:
{
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL2, 248));
}
break;
}
return;
}
error:
g_ifMng->SetMessage( g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMessage(LPACK_TYPE_NORMAL, 395));
}
void CWeatherSystem::
GTH_SendMessage_Request_WeatherSetting
( TIMESTATE weather, float limittime, bool IsUseItem , int invenpos )
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_REQUEST_USE_WEATHER_ITEM);
MSG_WriteByte(&netMessage, weather);
MSG_WriteLong(&netMessage, limittime);
MSG_WriteByte(&netMessage, IsUseItem);
if ( IsUseItem )
MSG_WriteByte(&netMessage, invenpos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_ProcessMessage_WeatherSystemEvent(void)
{
int state = MSG_ReadLong();
if ( state == (int)WEATHER_SYSTEM_WORLD_PROGRESS)
{
TIMESTATE WeatherType;
WeatherType = static_cast <TIMESTATE>(MSG_ReadLong());
g_timeSystem->SetTimeStateEnv (WeatherType);
}
else
{
g_timeSystem->SetTimeStateEnv (TIME_DAY);
}
}
void CWeatherSystem::GTH_SendMessageEventSeting(int event)
{
if ( event < 0)
event = 0;
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_BROAD_CASTING_EVENT_SETING);
MSG_WriteByte(&netMessage, event);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
if ( event == 0)
{
g_ifMng->AddChatMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 251), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322));
}
else
{
g_ifMng->AddChatMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 252), GTHCOLOR_SYSMESSAGE, g_LPACK.GetMessage(LPACK_TYPE_NORMAL,322));
}
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_WARNING_2 ), GTH_SOUND_PLAY_ONCE );
}
void CWeatherSystem::GTH_SendMessage_Request_WorldState(int worldidx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_REQUEST_WORLD_STATE);
MSG_WriteByte(&netMessage, worldidx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CWeatherSystem::GTH_ProcessMessage_Request_WorldState()
{
int reply = MSG_ReadByte();
TIMESTATE state = TIME_DAY;
if ( reply == 1)
{
state = static_cast<TIMESTATE>(MSG_ReadLong());
g_timeSystem->SetTimeStateEnv (state);
}
else
{
g_timeSystem->SetTimeStateEnv (TIME_DAY);
}
}
void CWeatherSystem::GTH_SendUserNotice(char *notice)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, WEATHER_SYSTEM );
MSG_WriteShort(&netMessage, CC_WEATHER_SYSTEM );
MSG_WriteByte(&netMessage, CC_WEATHER_SYSTEM_NOTICE);
MSG_WriteString(&netMessage, notice);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
| C++ |
#ifndef _SKILL_LOGIC_H
#define _SKILL_LOGIC_H
#define MAX_COUNT_SKILL_MULTI_TARGET 8
enum
{
SKILL_WEPON_TYPE=0,
SKILL_ITEM_TYPE,
};
class CSkillLogic
{
public:
bool m_bSendTransform;
public:
CSkillLogic();
~CSkillLogic();
bool GetMyCharTransform() { return m_bSendTransform; }
void SetMyCharTransform(bool flag) { m_bSendTransform = flag; }
bool CancelTransform(bool bSendCheck = false);
public:
int GTH_HaveSkill( int skillTableIdx );
void GTH_AddSkill( int idx, int skillTableIdx, int initLevel );
void GTH_GetSkillValue( int skillIdx, float value[] );
void GTH_GetSkillValue( int skillTableIdx, float value[], SKILL_GEN_LEVEL skillLevel );
int GTH_SkillProcess( int UseType, int Idx );
void GTH_SkillCoolTimeProcess();
int GTH_SkillClickEvent();
void GTH_AddSkillEffect( CSkillEffect *pEffect, Fx_CHARACTER_t *attacker, Fx_CHARACTER_t *defender, int effectLevel );
int GTH_SkillExecute( Fx_CHARACTER_t* character, int tableIdx, int level, int multiTargetNumber, int multiTargetType[], int multiTargetIdx[] ,int targetType);
int GTH_GetSkillEffectLevel( int skillTableIdx, int skillLevel );
int GTH_BeforeTeleportExecute( Fx_CHARACTER_t* character, int pcjob);
void GTH_AddSkillCastingEffect( Fx_CHARACTER_t *character, float castingTime );
int GTH_SkillCheckActive( int skillIdx );
float GTH_GetSkillActiveDistance();
void CheckSkillExecption(int weaponType, int skillIdx, int& aniID, CSkillEffect *pEffect);
float GTH_GetSkillActiveDistance(int SkillIndex,int TargetType);
int GTH_SkillProcess_TargetSetting(int &SkillTargetType,vec3_t &touched,vec3_t &delta);
void UnSelectSkill();
void CancelSkillProcess();
int GTH_SkillProcess_Skill(int Idx);
bool GTH_EnableSkillProcess(int Idx);
int GTH_SkillProcess_Item(int Idx);
void GTH_DeleteSKill(int idx);
};
extern CSkillLogic g_SkillLogic;
#endif | C++ |
#ifndef _EXPEVENTMNG_H_
#define _EXPEVENTMNG_H_
class CExpRateMng
{
private :
enum enumProtocal
{
CC_BROAD_CASE_SET_EVENT = 0x0001,
SS_BROAD_CASE_SET_EVENT = 0x0002,
SS_SET_EVENT = 0x0003,
SS_REQUEST_EVENT = 0x0004,
SS_REPLY_EVENT = 0x0005,
CC_SET_ACTIVE_SYSTEM = 0x0006,
SS_SET_ACTIVE_SYSTEM = 0x0007,
CC_REQUEST_EVENT_STATUS = 0X0008,
GSC_REPLY_EVENT_STATUS = 0X0009,
};
public:
enum enumEventType
{
EXP_RATE,
ITEM_DROP_RATE,
NAK_DROP_RATE,
GENCAPABLITY_RATE,
ALL_READ_LOGIC,
};
public:
void ProcessMessage();
void SendMessage_SetEvent(enum enumEventType eventTYpe, float fvalue );
void SendMessage_SetEventActive(BOOL Active = FALSE);
void SendMessage_RequestEventStatus();
void Processage_ReplyEventStatus();
public:
CExpRateMng();
~CExpRateMng();
};
#endif
| C++ |
#if !defined(AFX_ITEMUSEPROC_H__38065D89_2C16_4E42_A76E_DB9D72159A7B__INCLUDED_)
#define AFX_ITEMUSEPROC_H__38065D89_2C16_4E42_A76E_DB9D72159A7B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CItemUseProc
{
public:
CItemUseProc();
virtual ~CItemUseProc();
int RepairItem(const item_t *_item,const int _Pos);
int EpkItem(const item_t *_item,const int _Pos);
int WeatherSnowItem(const item_t *_item,const int _Pos);
int WeatherRainItem(const item_t *_item,const int _Pos);
int UseProc(const item_t *_item,const int _Pos);
int EtcItemTypeWorldPortal(const item_t *_item,const int _Pos);
int EtcItemTypeSkillSphere(const item_t *_item,const int _Pos);
int EtcItemTypePortal(const item_t *_item,const int _Pos);
int EtcItemTypeMonsterSphere(const item_t *_item,const int _Pos);
int QuestScroll(const item_t *_item,const int _Pos);
int AutoQuestScroll(const item_t *_item,const int _Pos);
int SurgeryItem(const item_t *_item,const int _Pos);
int ChatItem(const item_t *_item,const int _Pos);
int EtcItemTypeNone(const item_t *_item,const int _Pos);
int EtcItemTypeAutoQuestItem(const item_t *_item,const int _Pos);
int UseEtcTypeProc(const item_t *_item,const int _Pos);
int EpkMuchItem(const item_t *_item,const int _Pos);
int PcSummonItem(const item_t *_item,const int _Pos,const int _type);
int MessageProcessOk(int _msgType);
int UseItemMessage(const item_t *_item,const int _Pos);
};
#endif
| C++ |
#include "../global_def.h"
CHelperSystem::CHelperSystem()
{
m_iGivePoint = 0;
memset(&m_MyPointInfo, 0, sizeof(PointInfo));
for(int i=0; i < MAX_TAKER_LIST; i++)
memset(&m_HelperEntry[i], 0, sizeof(HelperEntry));
m_HelperEntry->bDeleteMe = FALSE;
}
CHelperSystem::~CHelperSystem() { }
void CHelperSystem::GTH_ProcessMessage_RecvHelpSystem()
{
int WhatDoYouMean = MSG_ReadShort();
switch(WhatDoYouMean)
{
case SC_INVITE_Req_toTAKER:
GTH_ProcessMessage_HelpSystem_NeedToHelper();
break;
case SC_INVITE_Res_toHELPER:
GTH_ProcessMessage_HelpSystem_DoYouWant();
break;
case SC_INVITE_Res_toTAKER:
GTH_ProcessMessage_HelpSystem_RequstComplete();
break;
case SC_REMOVE_Res_toPlayer:
GTH_ProcessMessage_HelpSystem_RemovePlayer();
break;
case SC_REMOVE_NOTIFY_toPlayer:
GTH_ProcessMessage_HelpSystem_NotifytoRemovePlayer();
break;
case SC_SEND_MEMBERLIST_toAllPlayer:
GTH_ProcessMessage_HelpSystem_UpDateListAll();
break;
case SC_SEND_ADD_toPlayer:
GTH_ProcessMessage_HelpSystem_AddToPlayer();
break;
case SC_LIST_Res_toServer:
GTH_ProcessMessage_HelpSystem_UpDateListAll();
break;
case SC_LISTINFO_toAllPlayer:
GTH_ProcessMessage_HelpSystem_UpDateList();
break;
case SC_UPDATE_POINTINFO_SEND_toPlayer:
GTH_ProcessMessage_HelpSystem_UpDatePointInfo();
break;
case SC_SPAWN_Req_toTaker:
GTH_ProcessMessage_HelpSystem_SpawnTaker();
break;
case SC_SPAWN_Req_toServer:
break;
case SC_SPAWN_Res_toTaker:
GTH_ProcessMessage_HelpSystem_Portal();
break;
case SC_SPAWN_Res_toServer:
break;
case SC_CONFIRM_MYPOINT_Res_toPlayer:
GTH_ProcessMessage_HelpSystem_DisplayMyPoint();
break;
case SC_CONFIRM_HELPPOINT_Res_toPlayer:
GTH_ProcessMessage_HelpSystem_DisplayHelpPoint();
break;
case SC_CONFIRM_WEPPOINT_Res_toPlayer:
GTH_ProcessMessage_HelpSystem_DisplayWebPoint();
break;
case SC_STACK_OPEN_Req_toPlayer:
GTH_ProcessMessage_HelpSystem_StackOpen();
break;
case SC_SENDMYPOINT_toAllPlayer:
GTH_ProcessMessage_HelpSystem_GivePointResultToTaker();
break;
case SC_SENDHELPPOINT_toHelper:
GTH_ProcessMessage_HelpSystem_GivePointResultToHelper();
break;
default:
return;
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_NeedToHelper(void)
{
char szMsg[256+1];
char szName[NAMESTRING+1];
strncpy(szName, MSG_ReadString(), NAMESTRING);
szName[NAMESTRING]=NULL;
_snprintf(szMsg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,296), szName);
szMsg[256]=NULL;
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,298), szMsg, MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_HELPERSYSTEM_DOYOUWANTME, 600000.0f);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_DoYouWant(void)
{
if( g_ifMng->m_msgType == IF_MESSAGE_HELPERSYSTEM_DOYOUWANTME )
g_ifMng->ExitMessage();
int Code = MSG_ReadShort();
switch(Code)
{
case 0:
g_ifMng->ExitMessage();
break;
case 1:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,386));
break;
case 2:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322),g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,589));
break;
case 3:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,294));
break;
case 4:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,388));
break;
case 6:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,389));
break;
case 7:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,295));
break;
case 8:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,318));
break;
case 13:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,390));
break;
case 15:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,293));
break;
case 16:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,590));
break;
case 17:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,591) );
break;
default:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,266));
break;
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_RequstComplete(void)
{
if( g_ifMng->m_msgType == IF_MESSAGE_HELPERSYSTEM_DOYOUWANTME )
g_ifMng->ExitMessage();
int errorCode = MSG_ReadShort();
if(errorCode)
{
switch(errorCode)
{
case 0:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,321));
break;
case 1:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,319));
break;
case 4:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,320));
break;
default:
break;
}
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_RemovePlayer(void)
{
int Code = MSG_ReadShort();
if(Code)
{
switch(Code)
{
case 10:
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,322));
break;
case 14:
char RemoveName[NAMESTRING+1];
strncpy(RemoveName, MSG_ReadString(), NAMESTRING);
RemoveName[NAMESTRING]=NULL;
g_ifMng->m_HelperWin->RemoveHelper(RemoveName);
break;
default:
break;
}
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_NotifytoRemovePlayer(void)
{
char EraserName[NAMESTRING+1];
strncpy(EraserName, MSG_ReadString(), NAMESTRING);
EraserName[NAMESTRING]=NULL;
char notify[256+1];
_snprintf(notify, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,323), EraserName);
notify[256]=NULL;
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), notify);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_AddToPlayer(void)
{
HelperEntry pHelperEntry;
pHelperEntry.level = MSG_ReadByte();
pHelperEntry.job = MSG_ReadByte();
pHelperEntry.worldIdx = MSG_ReadByte();
strncpy(pHelperEntry.name, MSG_ReadString(), NAMESTRING);
pHelperEntry.name[NAMESTRING]=NULL;
m_HelperEntry->bDeleteMe = FALSE;
g_ifMng->m_HelperWin->AddHelper(&pHelperEntry);
if( g_ifMng->m_msgType == IF_MESSAGE_HELPERSYSTEM_DOYOUWANTME )
g_ifMng->ExitMessage();
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_UpDateListAll(void)
{
for(int i=0; i < MAX_TAKER_LIST; i++)
{
memset(&m_HelperEntry[i], 0, sizeof(HelperEntry));
m_HelperEntry[i].bDeleteMe = FALSE;
}
g_ifMng->m_HelperWin->m_totalOnlineHelperCount = 0;
g_ifMng->m_HelperWin->m_selectedHelperIdx = -1;
g_ifMng->m_HelperWin->m_totalHelperCount = MSG_ReadByte();
g_ifMng->m_HelperWin->m_Mode = MSG_ReadShort();
for(i = 0; i < g_ifMng->m_HelperWin->m_totalHelperCount; i++)
{
m_HelperEntry[i].level = MSG_ReadByte();
m_HelperEntry[i].job = MSG_ReadByte();
m_HelperEntry[i].worldIdx = MSG_ReadByte();
strncpy(m_HelperEntry[i].name, MSG_ReadString(), NAMESTRING);
m_HelperEntry[i].name[NAMESTRING]=NULL;
m_HelperEntry[i].bDeleteMe = MSG_ReadByte();
if(g_HelperSystem.m_HelperEntry[i].worldIdx != -1 && g_HelperSystem.m_HelperEntry[i].worldIdx != 255 )
g_ifMng->m_HelperWin->m_totalOnlineHelperCount++;
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_UpDateList(void)
{
HelperEntry Entry;
Entry.level = MSG_ReadByte();
Entry.job = MSG_ReadByte();
Entry.worldIdx = MSG_ReadByte();
strncpy(Entry.name, MSG_ReadString(), NAMESTRING);
Entry.name[NAMESTRING]=NULL;
g_ifMng->m_HelperWin->UpdateHelper(&Entry);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_UpDatePointInfo(void)
{
m_MyPointInfo.iMyPoint = MSG_ReadLong();
m_MyPointInfo.iHelpPoint = MSG_ReadLong();
m_MyPointInfo.iTotalHelpPoint = MSG_ReadLong();
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_SpawnTaker(void)
{
char SpawnName[NAMESTRING+1];
char notify[256+1];
strncpy(SpawnName, MSG_ReadString(), NAMESTRING);
SpawnName[NAMESTRING]=NULL;
_snprintf(notify,256,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,324), SpawnName);
notify[256]=NULL;
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,316), notify, MSG_BUTTONTYPE_OKCANCEL, IF_MESSAGE_HELPERSYSTEM_DOYOUWANTPORTAL, 600000.0f);
g_ifMng->SetMessage(g_LPACK.GetMassage(0,322), notify);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_Portal(void)
{
int reply = MSG_ReadByte();
if(reply)
{
char PortalTargetCharacterName[NAMESTRING+1];
strncpy(PortalTargetCharacterName, MSG_ReadString(), NAMESTRING);
PortalTargetCharacterName[NAMESTRING]=NULL;
}
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_DisplayMyPoint(void)
{
char szTemp[256+1];
g_HelperSystem.m_MyPointInfo.iMyPoint = MSG_ReadLong();
_snprintf(szTemp,256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,330), g_HelperSystem.m_MyPointInfo.iMyPoint);
szTemp[256]=NULL;
g_ifMng->AddSysMessage(szTemp);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_DisplayHelpPoint(void)
{
char szTemp[256+1];
g_HelperSystem.m_MyPointInfo.iHelpPoint = MSG_ReadLong();
_snprintf(szTemp,256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,325), g_HelperSystem.m_MyPointInfo.iHelpPoint);
szTemp[256]=NULL;
g_ifMng->AddSysMessage(szTemp);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_DisplayWebPoint(void)
{
g_HelperSystem.m_MyPointInfo.iWebPoint = MSG_ReadLong();
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_StackOpen(void)
{
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_GivePointResultToTaker(void)
{
char szTemp[256+1];
char TakerName[NAMESTRING+1];
char HelperName[NAMESTRING+1];
strncpy(TakerName, MSG_ReadString(), NAMESTRING);
TakerName[NAMESTRING]=NULL;
strncpy(HelperName, MSG_ReadString(), NAMESTRING);
HelperName[NAMESTRING]=NULL;
int delta_HelpPoint = MSG_ReadLong();
_snprintf(szTemp,256,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,306),TakerName,HelperName,delta_HelpPoint);
szTemp[256]=NULL;
GTH_SendMessage_WorldChatting(szTemp, TRUE);
}
void CHelperSystem::GTH_ProcessMessage_HelpSystem_GivePointResultToHelper(void)
{
char szTemp[256+1];
char Name[NAMESTRING+1];
strncpy(Name, MSG_ReadString(), NAMESTRING);
Name[NAMESTRING]=NULL;
int delta_HelpPoint = MSG_ReadLong();
_snprintf(szTemp,256,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,307),delta_HelpPoint);
szTemp[256]=NULL;
g_ifMng->AddSysMessage(szTemp);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_DoYouWant(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_INVITE_Req_fromHELPER);
MSG_WriteString(&netMessage, g_cgv.pTargetChar->name);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_AnswerYesOrNo(int Answer)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_INVITE_Res_fromTAKER);
MSG_WriteShort(&netMessage, Answer);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_RemovePlayer(char *DeleteHelperName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_REMOVE_Req_fromPlayer);
MSG_WriteString(&netMessage, DeleteHelperName);
MSG_WriteString(&netMessage, g_cgv.myCharacterInfo->name);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_GivePointToHelper(int GivePoint, char *HelperName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_GIVEPOINT_Req_toHelper);
MSG_WriteLong(&netMessage, m_iGivePoint);
MSG_WriteString(&netMessage, HelperName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_SpawnTaker(char *SpawnHelperName)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_SPAWN_Req_fromHelper);
MSG_WriteString(&netMessage, SpawnHelperName);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_SpawnMeAnswer(int YesOrNo)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_SPAWN_Res_fromTaker);
MSG_WriteByte(&netMessage, YesOrNo);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_DisplayMyPoint(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_CONFIRM_MYPOINT_Req_fromPlayer);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_DisplayHelpPoint(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_CONFIRM_HELPPOINT_Req_fromPlayer);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_DisplayWebPoint(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_CONFIRM_WEPPOINT_Req_fromPlayer);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void CHelperSystem::GTH_SendMessage_HelpSystem_GiveMeListAll(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, HELPER_SYSTEM);
MSG_WriteShort(&netMessage, CS_MemBerList_Req_fromPlayer);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
BOOL CHelperSystem::IsChild(char* TarketName)
{
for( int nIdx = 0; nIdx < g_ifMng->m_HelperWin->m_totalHelperCount; nIdx++){
if( 0 == strncmp(m_HelperEntry[nIdx].name,TarketName,NAMESTRING) ) return TRUE;
}
return FALSE;
}
| C++ |
#include "../global_def.h"
CPostFunc::CPostFunc(){ }
CPostFunc::~CPostFunc(){ }
#include "..\CTools.h"
void CPostFunc::GTH_ProcessMessage_RecvPostSystem()
{
int command = MSG_ReadByte();
switch( command )
{
case POSTSYSTEM_OPEN:
GTH_ProcessMessage_PostSystem_OpenWindow();
break;
case POSTSYSTEM_EXIT_WIN:
GTH_ProcessMessage_PostSystem_ExitWindow();
break;
case POSTSYSTEM_SEND :
GTH_ProcessMessage_PostSystem_Send();
break;
case POSTSYSTEM_DELETE:
GTH_ProcessMessage_PostSystem_DeletePost();
break;
case POSTSYSTEM_STATE:
GTH_ProcessMessage_PostSystem_State();
break;
case POSTSYSTEM_WRITEOPEN:
GTH_ProcessMessage_PostSystem_WriteOpen();
break;
case POSTSYSTEM_SENDCOMPLETE:
GTH_ProcessMessage_PostSystem_SendComplete();
break;
case POSTSYSTEM_NOTIFY :
GTH_ProcessMessage_PostSystem_Arrive();
break;
}
}
void CPostFunc::GTH_ProcessMessage_PostSystem_SendComplete(void)
{
int reply = MSG_ReadLong();
int error = MSG_ReadByte();
if(reply)
g_ifMng->m_mailBoxWin->SendItemDelete();
}
bool CPostFunc::Safe_ItemBox(int index)
{
if(index < 0 || index >= MAX_NUMBER_OF_OWNITEM) return false;
return true;
}
int CPostFunc::GetItemCount()
{
int total=0;
for(int pos = 0; pos < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; pos++)
{
int index = g_cgv.myCharacterInfo->m_ItemsInPost[pos];
if(!Safe_ItemBox(index)) continue;
if(&g_cgv.myCharacterInfo->item[index] != NULL)
total++;
}
return total;
}
void CPostFunc::GTH_SendMessage_PostSystem_Send()
{
char name[NAMESTRING+1];
char title[CPostManager::POST_TITLESIZE+1];
char message[CPostManager::POST_STRSIZE+1];
strncpy(name,g_ifMng->m_mailBoxWin->m_name,NAMESTRING);
name[NAMESTRING]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(name);
strncpy(title,g_ifMng->m_mailBoxWin->m_title,CPostManager::POST_TITLESIZE);
title[CPostManager::POST_TITLESIZE]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(title);
strncpy(message,g_ifMng->m_mailBoxWin->m_message,CPostManager::POST_STRSIZE);
message[CPostManager::POST_STRSIZE]=NULL;
CTools::Replace_singleQUOTATIONmark_by_doubleQUOTATIONmark(message);
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_SEND);
MSG_WriteString(&netMessage, name);
MSG_WriteString(&netMessage, title);
MSG_WriteString(&netMessage, message);
MSG_WriteLong(&netMessage, g_ifMng->m_mailBoxWin->m_nak);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
int CPostFunc::GTH_SendMessage_PostSystem_ReceiveItems()
{
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetOpenPost();
int OpenIdx = g_cgv.myCharacterInfo->m_PostMng.m_OpenPostIdx;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_RECEIVE_ITEMS );
MSG_WriteLong(&netMessage, OpenIdx );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
inline void CPostFunc::GTH_ProcessMessage_PostSystem_ReceiveItems_Success(void)
{
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetOpenPost();
if(NULL == pPostPackage) return;
int inventoryPos = -1;
int itemIdx = -1;
for ( int i = 0; i < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; i ++)
{
item_t *pitem = NULL;
pitem = &pPostPackage->Items[i];
if ( pitem == NULL || pitem->itemTableIdx < 0)
continue;
int stackItemIdx = GTH_StackMyItem( pitem );
if( stackItemIdx >= 0 )
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += pitem->durability + 1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability + 1 >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos();
itemIdx = GTH_AddMyItem( pitem );
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
}
GTH_InitItem(pitem);
pPostPackage->ItemNumber--;
}
g_cgv.myCharacterInfo->curChargeSE +=pPostPackage->Nak;
pPostPackage->Nak = 0;
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_EQUIP_ITEM ), GTH_SOUND_PLAY_ONCE );
GTH_SendMessageRequestItemSyncItem();
}
void CPostFunc::GTH_ProcessMessage_PostSystem_ReceiveItems()
{
int reply = MSG_ReadLong();
int error = 1;
if ( reply == 1)
GTH_ProcessMessage_PostSystem_ReceiveItems_Success();
else
{
error = MSG_ReadLong();
switch( error )
{
case 3:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 217) );
break;
case 4:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 262) );
break;
default:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 227) );
break;
}
}
g_chatManager->SetInputState( INPUT_INDEX_POST_NAME, -1 );
g_chatManager->SetInputState( INPUT_INDEX_POST_MESSAGE, -1 );
g_chatManager->SetInputState( INPUT_INDEX_POST_TITLE, -1 );
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
}
void CPostFunc::GTH_SendMessage_PostSystem_State()
{
int state = g_cgv.myCharacterInfo->m_PostMng.GetState();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_STATE );
MSG_WriteByte(&netMessage, state);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CPostFunc::GTH_SendMessage_PostSystem_View()
{
}
void CPostFunc::GTH_ProcessMessage_PostSystem_OpenWindow()
{
int PostIdx = 0;
int PostCount = -1;
enum tagGCPacket_POSTSYSTEM_OPEN::enumCode code =
tagGCPacket_POSTSYSTEM_OPEN::enumCode::fail;
code = static_cast<enum tagGCPacket_POSTSYSTEM_OPEN::enumCode>(MSG_ReadByte());
switch( code )
{
case tagGCPacket_POSTSYSTEM_OPEN::enumCode::success:
{
PostCount = MSG_ReadLong();
g_cgv.myCharacterInfo->m_PostMng.InitPostSystem();
for ( PostIdx = 0; PostIdx < PostCount; PostIdx++)
{
CPostManager::PostPackage_t PostPackage;
memset(&PostPackage, 0, sizeof(CPostManager::PostPackage_t) );
PostPackage.iPostIdx = MSG_ReadLong();
sstrncpy(PostPackage.szFromName, MSG_ReadString(), NAMESTRING);
PostPackage.szFromName[NAMESTRING] = NULL;
CTools::Replace_doubleQUOTATIONmark_by_singleQUOTATIONmark(PostPackage.szFromName);
sstrncpy(PostPackage.szPostTitle, MSG_ReadString(), CPostManager::POST_TITLESIZE);
PostPackage.szPostTitle[CPostManager::POST_TITLESIZE] = NULL;
CTools::Replace_doubleQUOTATIONmark_by_singleQUOTATIONmark(PostPackage.szPostTitle);
sstrncpy(PostPackage.szSendPostTime , MSG_ReadString(), CPostManager::POST_SENDTIME_INFO_STR_LEN);
PostPackage.szSendPostTime[CPostManager::POST_SENDTIME_INFO_STR_LEN] = NULL;
sstrncpy(PostPackage.szMailStr, MSG_ReadString(), CPostManager::POST_STRSIZE);
PostPackage.szMailStr[CPostManager::POST_STRSIZE] = NULL;
CTools::Replace_doubleQUOTATIONmark_by_singleQUOTATIONmark(PostPackage.szMailStr);
int state = MSG_ReadLong();
if ( state == 0)
PostPackage.MailState = CPostManager::enumPostPackageState::POSTPACKAGE_UNCHECK;
else
PostPackage.MailState = CPostManager::enumPostPackageState::POSTPACKAGE_CHECK;
int nak = MSG_ReadLong();
PostPackage.Nak = nak;
int SendType = MSG_ReadLong();
PostPackage.iRemainDays = MSG_ReadLong();
if ( SendType == 0)
PostPackage.PostSendType = CPostManager::enumPostSendType::POST_SENDTYPE_WEB;
else
PostPackage.PostSendType = CPostManager::enumPostSendType::POST_SENDTYPE_CHAR;
g_cgv.myCharacterInfo->m_PostMng.AddPostPackage(PostPackage);
}
g_ifMng->m_PostWin->InitIFPost();
g_ifMng->m_PostWin->SetDisplayMode(true);
g_ifMng->m_chatWin->Enable( false );
g_ifMng->m_PostWin->Enable(1);
g_ifMng->SetFocus( g_ifMng->m_PostWin );
}
break;
case tagGCPacket_POSTSYSTEM_OPEN::enumCode::fail:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 226) );
break;
default:
break;
}
}
void CPostFunc::GTH_ProcessMessage_PostSystem_Send()
{
int reply = -1, error = -1;
reply = MSG_ReadByte();
if(reply > 0)
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 263));
}
else
{
error = MSG_ReadByte();
switch(error)
{
case 0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 264));
break;
case 1:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 265));
break;
case 2:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 266));
break;
case 3:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 270));
break;
default:
break;
}
}
}
void CPostFunc::GTH_ProcessMessage_PostSystem_State()
{
int reply = -1;
reply = MSG_ReadByte();
if(reply)
g_cgv.myCharacterInfo->m_PostMng.InverseState();
}
void CPostFunc::GTH_SendMessage_PostSystem_WriteOpen(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_POSTSYSTEM);
MSG_WriteByte(&netMessage, POSTSYSTEM_WRITEOPEN);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CPostFunc::GTH_ProcessMessage_PostSystem_WriteOpen(void)
{
int reply = -1;
int error = -1;
reply = MSG_ReadByte();
g_ifMng->m_mailBoxWin->InitMailBoxWin();
if ( reply == TRUE )
{
g_chatManager->InitInputStr(INPUT_INDEX_POST_NAME);
g_chatManager->InitInputStr(INPUT_INDEX_POST_TITLE);
g_chatManager->InitInputStr(INPUT_INDEX_POST_MESSAGE);
g_ifMng->m_PostWin->Enable(false);
g_ifMng->m_PostWin->m_bDisplay = false;
g_ifMng->m_charWin->Enable(false);
g_ifMng->m_itemWin->Enable(true);
g_ifMng->m_mailBoxWin->Enable(true);
g_ifMng->m_mailBoxWin->m_bDisplay = true;
g_ifMng->SetFocus(g_ifMng->m_mailBoxWin);
CPostManager::PostPackage_t postpackage;
g_cgv.myCharacterInfo->m_PostMng.InitPostSystem();
g_cgv.myCharacterInfo->m_PostMng.SetPostSystem(CPostManager::enumPostPackageMode::POSTSYSTEM_WRITEMODE);
g_cgv.myCharacterInfo->m_PostMng.InitPackage(&postpackage);
g_cgv.myCharacterInfo->m_PostMng.AddPostPackage(postpackage);
g_cgv.myCharacterInfo->m_PostMng.SetOpenPost(g_cgv.myCharacterInfo->m_PostMng.GetPostCount() - 1);
}
else
{
error = MSG_ReadByte();
if ( error == 0)
{
}
}
}
void CPostFunc::GTH_ProcessMessage_PostSystem_View()
{
}
void CPostFunc::GTH_ProcessMessage_PostSystem_Arrive()
{
int iUnReadedCnt = MSG_ReadLong();
int iReadCnt = MSG_ReadLong();
if(iUnReadedCnt >= 1){
char message[_MAX_PATH];
wsprintf(message,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,267),iUnReadedCnt);
g_ifMng->AddSysMessage(message, GTHCOLOR_NOTICEMESSAGE );
g_ifMng->AddSysMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,268), GTHCOLOR_NOTICEMESSAGE );
}
}
void CPostFunc::GTH_ProcessMessage_MailBox_Open()
{
int reply = -1;
int itemNumber;
int PostIdx = -1;
CPostManager::PostPackage_t* pPostPackage = NULL;
reply = MSG_ReadByte();
g_ifMng->m_mailBoxWin->InitMailBoxWin();
if ( reply )
{
PostIdx = MSG_ReadLong();
if ( PostIdx <0 )
return;
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetOpenPost();
itemNumber = MSG_ReadLong();
if ( pPostPackage == NULL)
return;
pPostPackage->ItemNumber = itemNumber;
for (int i = 0; i < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; i++)
{
GTH_InitItem(&pPostPackage->Items[i]);
MSG_ReadItem(&pPostPackage->Items[i]);
}
g_ifMng->m_PostWin->Enable(false);
g_ifMng->m_PostWin->m_bDisplay = false;
g_ifMng->m_charWin->Enable(false);
g_ifMng->m_itemWin->Enable(true);
g_ifMng->m_mailBoxWin->Enable(true);
g_ifMng->m_mailBoxWin->m_bDisplay = true;
g_ifMng->SetFocus(g_ifMng->m_mailBoxWin);
}
else
{
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 227) );
}
}
void CPostFunc::GTH_ProcessMessage_RecvMailBox()
{
int command;
command = MSG_ReadByte();
switch( command )
{
case MAILBOX_OPEN :
GTH_ProcessMessage_MailBox_Open();
break;
case MAILBOX_EXIT :
GTH_ProcessMessage_MailBox_Exit();
break;
case MAILBOX_ITEM :
GTH_ProcessMessage_MailBox_Item();
break;
case MAILBOX_RECEIVE_ITEMS :
GTH_ProcessMessage_PostSystem_ReceiveItems();
break;
case MAILBOX_UNDOINVENITEM:
GTH_ProcessMessage_MailBox_UndoInvenItem();
break;
}
}
void CPostFunc::GTH_ProcessMessage_MailBox_UndoInvenItem(void)
{
GTH_UnlockSending();
int reply = 1, error = -1;
reply = MSG_ReadLong();
if(reply)
g_ifMng->m_mailBoxWin->UndoMailBoxInventory();
else
error = MSG_ReadByte();
}
bool CPostFunc::GTH_SendMessage_MailBox_UndoInvenItem(void)
{
MSG_BeginWriting(&netMessage);
MSG_Clear(&netMessage);
{
MSG_WriteByte(&netMessage, CC_EXTEND);
MSG_WriteByte(&netMessage, CC_MAILBOX);
MSG_WriteByte(&netMessage, MAILBOX_UNDOINVENITEM);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
return true;
}
int CPostFunc::GTH_SendMessage_MailBox_Open(int PostType, int PostIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_OPEN );
MSG_WriteLong(&netMessage, PostType );
MSG_WriteLong(&netMessage, PostIdx );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
int CPostFunc::GTH_SendMessage_MailBox_Item( int idx, int pos )
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_ITEM );
MSG_WriteByte(&netMessage, pos );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
int CPostFunc::GTH_ProcessMessage_MailBox_Item()
{
GTH_UnlockSending();
int reply = 1, error = 0;
int pos, isOwner, ItemTableIdx;
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetOpenPost();
reply = MSG_ReadLong();
if( reply > 0 )
{
isOwner = MSG_ReadByte();
pos = MSG_ReadByte();
g_cgv.myCharacterInfo->mouseInventory = MSG_ReadShort();
g_cgv.myCharacterInfo->m_ItemsInPost[pos] = MSG_ReadShort();
ItemTableIdx = MSG_ReadShort();
}
else
{
error = MSG_ReadByte();
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 269));
}
return 1;
}
void CPostFunc::GTH_ProcessMessage_MailBox_Exit()
{
CPostManager::PostPackage_t* pPostPackage = NULL;
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetOpenPost();
for (int i = 0; i < CPostManager::MAX_ITEMCOUNT_IN_POSTPACKAGE; i ++)
{
if ( g_cgv.myCharacterInfo->m_ItemsInPost[i] < 0)
continue;
int pos = g_cgv.myCharacterInfo->m_ItemsInPost[i];
}
g_ifMng->m_mailBoxWin->Enable(false);
g_ifMng->SetFocus(g_ifMng->m_PostWin);
}
int CPostFunc::GTH_SendMessage_MailBox_Exit()
{
g_ifMng->m_mailBoxWin->UndoMailBoxInventory();
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_MAILBOX );
MSG_WriteByte(&netMessage, MAILBOX_EXIT );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
return 1;
}
void CPostFunc::GTH_ProcessMessage_PostSystem_ExitWindow()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_EXIT_WIN );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CPostFunc::GTH_SendMessage_PostSystem_DeletePost()
{
int DeleteCount = g_cgv.myCharacterInfo->m_PostMng.GetCheckCount();
if ( DeleteCount < 0 )
DeleteCount = 0;
int MaxPostCount = g_cgv.myCharacterInfo->m_PostMng.GetPostCount();
if ( DeleteCount > MaxPostCount)
DeleteCount = MaxPostCount;
CPostManager::PostPackage_t* pPostPackage = NULL;
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, CC_EXTEND );
MSG_WriteByte(&netMessage, CC_POSTSYSTEM );
MSG_WriteByte(&netMessage, POSTSYSTEM_DELETE );
MSG_WriteLong(&netMessage, DeleteCount);
for (int PostIdx = 0; PostIdx < MaxPostCount; PostIdx ++)
{
pPostPackage = g_cgv.myCharacterInfo->m_PostMng.GetPostPackage(PostIdx);
if ( pPostPackage == NULL || pPostPackage->bCheck == false)
continue;
MSG_WriteLong(&netMessage, PostIdx);
}
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void CPostFunc::GTH_ProcessMessage_PostSystem_DeletePost(void)
{
int reply = -1, error = -1;
reply = MSG_ReadLong();
if(reply <= 0)
{
error = MSG_ReadLong();
switch(error)
{
case 0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 281));
break;
default:
break;
}
}
} | C++ |
#include "../global_def.h"
WorldChangeSystem::WorldChangeSystem()
{
m_SaveInvenPos = -1;
m_SelectWorldIdx = -1;
m_SystemMode = WORLD_CHANGESYSTEM_NONE;
}
| C++ |
#include "../global_def.h"
void GTH_ItemExtendSystemDecode(void)
{
SHORT Packet = static_cast<enum enumItemExtendSystemPacket>(MSG_ReadShort());
switch(Packet)
{
case REPLY_ITEM_SYNC_TIME:
GTH_ProcessMessage_ItemSyncTime();
break;
case REPLY_ITEM_TIME_SET:
GTH_ProcessMessageReplyItemTimeSet();
break;
}
}
void GTH_ProcessMessage_ItemSyncTime()
{
int MaxSize = 0;
MaxSize = MSG_ReadLong();
for (int nReciveIdx =0; nReciveIdx < MaxSize; nReciveIdx++)
{
int ItemIdx = MSG_ReadLong();
item_t Item;
GTH_InitItem(&Item);
MSG_ReadItem(&Item);
if ( ItemIdx >= 0|| ItemIdx < MAX_NUMBER_OF_OWNITEM )
memcpy(&g_cgv.myCharacterInfo->item[ItemIdx], &Item, sizeof(item_t));
}
}
void GTH_SendMessageRequestItemSyncItem()
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REQUEST_ITEM_SYNC_TIME);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequestItemTimeSet(const enum sItemUseTimeInfo::enumInventoryType type, int iItemIdx, int iinvenIdx)
{
MSG_BeginWriting(&netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, ITEM_EXTEND_SYSTEM);
MSG_WriteShort(&netMessage, REQUEST_ITEM_TIME_SET);
MSG_WriteLong(&netMessage, (int)type);
MSG_WriteLong(&netMessage, iItemIdx);
MSG_WriteLong(&netMessage, iinvenIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessItemTimeSet(const int nItemIdx)
{
enum sItemUseTimeInfo::enumInventoryType type;
int nInvenIdx = -1;
type = GetItemInvenType(nItemIdx, nInvenIdx);
if ( type != sItemUseTimeInfo::enumInventoryType::ITEM_UNKNOW)
GTH_SendMessageRequestItemTimeSet(type, nItemIdx, nInvenIdx);
}
enum sItemUseTimeInfo::enumInventoryType GetItemInvenType(const int nItemIdx, int &iInvenToryPos)
{
int nInvenIdx = 0;
for ( nInvenIdx = 0; nInvenIdx < MAX_INVENTORY_SIZE ; nInvenIdx++)
{
if (g_cgv.myCharacterInfo->inventory[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_INVEN;
}
}
for (nInvenIdx = 0; nInvenIdx < MAX_EQUIPMENT ; nInvenIdx++)
{
if (g_cgv.myCharacterInfo->equipment[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_UPGRADE_SOURCE_ITEM_SIZE ; nInvenIdx++)
{
if ( g_cgv.myCharacterInfo->upgradeSourceInventory[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_UPGRADE;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_TRADE_SIZE; nInvenIdx ++)
{
if ( g_GonryunBattlePractic.m_imyTradetemp[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_GB_BATTING;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_PRECOCITY_SIZE; nInvenIdx ++)
{
if ( g_cgv.myCharacterInfo->precocityInventory[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_PRECOCITY;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_CRAFT_SOURCE_ITEM_SIZE; nInvenIdx ++)
{
if ( g_cgv.myCharacterInfo->craftSourceInventory[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_CRAFT;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_DEPOT_SIZE; nInvenIdx ++)
{
if ( g_cgv.myCharacterInfo->depot[nInvenIdx] == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_DEPOT;
}
}
for ( nInvenIdx = 0; nInvenIdx < MAX_BOOTH_INVENTORY_SIZE; nInvenIdx ++)
{
if ( g_cgv.myCharacterInfo->boothInventory[nInvenIdx].itemIdx == nItemIdx )
{
iInvenToryPos = nInvenIdx;
return sItemUseTimeInfo::enumInventoryType::ITEM_BOOTHINVENTORY;
}
}
if ( g_cgv.myCharacterInfo->mouseInventory == nItemIdx)
return sItemUseTimeInfo::enumInventoryType::ITEM_MOUSEIN;
return sItemUseTimeInfo::enumInventoryType::ITEM_UNKNOW;
};
void GTH_ProcessMessageReplyItemTimeSet()
{
int Reply = MSG_ReadLong();
if ( Reply == 1)
{
char msg[256];
item_t item;
MSG_ReadItem(&item);
sItemUseTimeInfo::enumInventoryType type;
type = static_cast<enum sItemUseTimeInfo::enumInventoryType>(MSG_ReadLong());
int nItemIdx = MSG_ReadLong();
int nInvenIdx = MSG_ReadLong();
BOOL bReplaceItem = MSG_ReadLong();
if (nItemIdx < 0 || nItemIdx >= MAX_NUMBER_OF_OWNITEM )
return;
_snprintf(msg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 547), g_cgv.myCharacterInfo->item[nItemIdx].name);
msg[255] = NULL;
ItemDestroyNotice(msg);
GTH_DeleteMyItem( &g_cgv.myCharacterInfo->item[nItemIdx] );
if ( type == sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP)
{
GTH_ReplaceItem(type, nInvenIdx, -1);
int inventoryPos = GTH_FindEmptyInventoryPos();
if( inventoryPos >= 0 )
{
int RegItemIdx = GTH_AddMyItem(&item);
g_cgv.myCharacterInfo->inventory[inventoryPos] = RegItemIdx;
}
}
else
{
int RegItemIdx = GTH_AddMyItem(&item);
GTH_ReplaceItem(type, nInvenIdx, RegItemIdx);
}
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_EQUIP_ITEM ), GTH_SOUND_PLAY_ONCE );
}
else
{
int ErrorIdx = MSG_ReadLong();
switch(ErrorIdx)
{
case sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR1:
{
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(0,48), 1, IF_MESSAGE_NONE );
}
break;
case sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR2:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,548), 1, IF_MESSAGE_NONE );
break;
case sItemUseTimeInfo::enumItemExptendError::ITEM_EXTEND_ERROR3:
g_ifMng->SetMessage( g_LPACK.GetMassage(0,322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,549), 1, IF_MESSAGE_NONE );
break;
}
}
}
BOOL GTH_ReplaceItem(const enum sItemUseTimeInfo::enumInventoryType type, int iInvenPos, int NewItemIdx)
{
switch (type)
{
case sItemUseTimeInfo::enumInventoryType::ITEM_INVEN:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_INVENTORY_SIZE)
return FALSE;
g_cgv.myCharacterInfo->inventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_UPGRADE:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_UPGRADE_SOURCE_ITEM_SIZE)
return FALSE;
g_cgv.myCharacterInfo->upgradeSourceInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_EQUIP:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_EQUIPMENT)
return FALSE;
g_cgv.myCharacterInfo->equipment[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_GB_BATTING:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_TRADE_SIZE)
return FALSE;
g_GonryunBattlePractic.m_imyTradetemp[iInvenPos]
= NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_PRECOCITY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_PRECOCITY_SIZE)
return FALSE;
g_cgv.myCharacterInfo->precocityInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_CRAFT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_CRAFT_SOURCE_ITEM_SIZE)
return FALSE;
g_cgv.myCharacterInfo->craftSourceInventory[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_DEPOT:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_DEPOT_SIZE)
return FALSE;
g_cgv.myCharacterInfo->depot[iInvenPos] = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_BOOTHINVENTORY:
{
if ( iInvenPos < 0 || iInvenPos >= MAX_BOOTH_INVENTORY_SIZE)
return FALSE;
g_cgv.myCharacterInfo->boothInventory[iInvenPos].itemIdx = NewItemIdx;
}
break;
case sItemUseTimeInfo::enumInventoryType::ITEM_MOUSEIN:
{
g_cgv.myCharacterInfo->mouseInventoryType = NewItemIdx;
}
break;
}
return TRUE;
}
void GTH_ItemUseTimeProcess()
{
if ( iSTickPerSec() == FALSE)
return;
char msg[256];
for( int iItemIdx = 0; iItemIdx < MAX_NUMBER_OF_OWNITEM; iItemIdx ++ )
{
item_t *pItem = &g_cgv.myCharacterInfo->item[iItemIdx];
int *pitemTime = NULL;
if ( IsItemUseFlag(pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_TIME) )
pitemTime = &pItem->ItemExtendInfo.AllowUseTime;
if ( IsItemUseFlag(pItem, item_t::sItemExtendInfo::enumItemUseFlag::ITEM_USE_FLAG_USE_DATE ) )
pitemTime = &pItem->ItemExtendInfo.CalclateUseDateToSec;
if ( NULL == pitemTime )
continue;
if ( (*pitemTime) < 0 )
continue;
(*pitemTime) --;
if ( (*pitemTime) == sItemUseTimeInfo::enumItemSyncInfo::ITEM_DESTROY_NOTICE_5MIN)
{
_snprintf(msg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 550),
pItem->name, 5, 5, pItem->name );
ItemDestroyNotice(msg);
}
if ( (*pitemTime) == sItemUseTimeInfo::enumItemSyncInfo::ITEM_DESTROY_NOTICE_1MIN )
{
_snprintf(msg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 550),
pItem->name, 1, 1, pItem->name );
ItemDestroyNotice(msg);
}
if ( (*pitemTime) < 0 )
GTH_ProcessItemTimeSet(iItemIdx);
}
}
BOOL iSTickPerSec()
{
static float fLastAppTime = g_timer.GetAppTime();
if ( g_timer.GetAppTime() - fLastAppTime >= 1.0F)
{
fLastAppTime = g_timer.GetAppTime();
return TRUE;
}
return FALSE;
}
void ItemDestroyNotice(char* szmsg)
{
if ( NULL == szmsg)
return;
g_ifMng->m_GmNotice = FALSE;
g_ifMng->AddSysMessage( szmsg, GTHCOLOR_ITEMNOTICE_MESSAGE );
g_ifMng->AddNoticeMessage( szmsg, GTHCOLOR_ITEMNOTICE_MESSAGE );
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_WARNING_2 ), GTH_SOUND_PLAY_ONCE );
} | C++ |
#if !defined(AFX_GAMECONFIGFLAG_H__64911BCF_348E_4592_AE6E_C851A9E5E8B1__INCLUDED_)
#define AFX_GAMECONFIGFLAG_H__64911BCF_348E_4592_AE6E_C851A9E5E8B1__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
class CGameConfigFlag
{
public:
CGameConfigFlag()
{
Init();
}
virtual ~CGameConfigFlag()
{
}
void Init()
{
m_bCharacter_Storage =FALSE;
m_bPrecocity_Time =FALSE;
m_bDie_Reduce_panality =FALSE;
m_bMap_Attr_Ratio =FALSE;
m_bItem_Upgrade_Limit =FALSE;
m_bItem_Craft_Limit =FALSE;
m_bWorld_Chat_Limit =FALSE;
m_nFlag=0;
}
int LoadFlagFile();
int GetFlag()
{
return m_nFlag;
}
void SetFlag(int flag);
void SetFlag();
public:
BOOL m_bCharacter_Storage;
BOOL m_bPrecocity_Time;
BOOL m_bDie_Reduce_panality;
BOOL m_bMap_Attr_Ratio;
BOOL m_bItem_Upgrade_Limit;
BOOL m_bItem_Craft_Limit;
BOOL m_bWorld_Chat_Limit;
int m_nFlag;
};
extern CGameConfigFlag gGameConfigFlag;
#endif
| C++ |
#include "../global_def.h"
void GTH_WorldChangeSystem_Process()
{
int command = MSG_ReadByte();
switch(command)
{
case GTH_REPLY_USE_ITEM:
GTH_ProcessMessage_Reply_WorldChangeUseItem();
break;
case GTH_REPLY_WORLD_CHANGE:
GTH_ProcessMessage_Reply_WorldChange();
break;
case GTH_CLEAR_WORLD_CHANGE_MODE:
GTH_ProcessMessage_ClearWorldChageMode();
break;
}
}
void GTH_SendMessage_Request_WorldChangeUseItem(WorldChangeSystem *pWorldChangeSystem)
{
MSG_BeginWriting( &netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, CC_EXTEND);
MSG_WriteByte ( &netMessage, CC_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, GTH_REQUEST_USE_ITEM);
MSG_WriteByte ( &netMessage, pWorldChangeSystem->m_SaveInvenPos);
NET_SendMessage ( &gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_ProcessMessage_Reply_WorldChangeUseItem()
{
int reply = 0;
int erroridx = 0;
reply = MSG_ReadByte();
if ( reply == 0 )
{
erroridx = MSG_ReadLong();
switch(erroridx) {
case 1:
break;
case 2:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 283) );
break;
}
}
else
{
g_ifMng->m_WorldChangeWin->Enable();
g_ifMng->SetFocus( g_ifMng->m_WorldChangeWin);
}
}
void GTH_SendMessage_Request_WorldChange(WorldChangeSystem *pWorldChangeSystem)
{
MSG_BeginWriting( &netMessage);
MSG_Clear( &netMessage );
{
MSG_WriteByte ( &netMessage, CC_EXTEND);
MSG_WriteByte ( &netMessage, CC_WORLD_CHANGE);
MSG_WriteByte ( &netMessage, GTH_REQUEST_WORLD_CHANGE);
MSG_WriteLong ( &netMessage, pWorldChangeSystem->m_SaveInvenPos);
MSG_WriteLong ( &netMessage, pWorldChangeSystem->m_SelectWorldIdx);
NET_SendMessage ( &gsSocket, &netMessage);
}
MSG_EndWriting( &netMessage );
}
void GTH_ProcessMessage_Reply_WorldChange()
{
int reply = 0;
int saveInvenPos = 0;
int errorIdx = 0;
char strbuffer[MAX_PATH];
reply = MSG_ReadByte();
if ( reply == 0 )
{
errorIdx = MSG_ReadByte();
switch(errorIdx)
{
case 0:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 284) );
break;
case 1:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 285) );
break;
case 2:
g_ifMng->SetMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 286) );
break;
case 3:
g_ifMng->SetMessage(
g_LPACK.GetMassage(LPACK_TYPE_NORMAL,322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,588),
MSG_BUTTONTYPE_OK,
IF_MESSAGE_NONE);
break;
}
}
else
{
saveInvenPos = MSG_ReadLong();
int itemIdx = g_cgv.myCharacterInfo->inventory[saveInvenPos];
item_t *pItem = &g_cgv.myCharacterInfo->item[itemIdx];
if ( g_itemTable[pItem->itemTableIdx].stackFlag == 1)
GTH_UseItem_Delete(saveInvenPos);
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL,
WorldChangeSystem::WORLD_CHANGE_EFFECT_IDX,
g_pApp->m_myCharacter->position,
NULL,
true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f,
0.0f,
0.0f,
-1.0f,
false );
g_ifMng->m_WorldChangeWin->Enable(false);
g_ifMng->m_itemWin->Enable(false);
int SelectWorldIdx = g_cgv.myCharacterInfo->m_WorldChageSystem.m_SelectWorldIdx;
_snprintf(strbuffer, MAX_PATH, "%s %s", g_cgv.worldTable[SelectWorldIdx].hanName,
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 287));
strbuffer[MAX_PATH-1] = NULL;
g_ifMng->AddSysMessage( strbuffer, D3DCOLOR_ARGB(255, 255, 125, 100) );
SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_EFFECT_MODE);
}
}
BOOL IsAllowWorldChange_ForPcEvent()
{
if ( g_pApp->m_myCharacter->isAlive = 0)
return 2;
switch(g_pApp->m_myCharacter->event)
{
case GTH_EV_CHAR_ATTACK:
case GTH_EV_CHAR_SKILL:
case GTH_EV_CHAR_SKILLCASTING:
case GTH_EV_CHAR_BEFORE_TELEPORT:
case GTH_EV_CHAR_TELEPORT:
case GTH_EV_CHAR_FREEZE:
case GTH_EV_CHAR_PUSHED:
case GTH_EV_CHAR_HIDE:
return 3;
}
return 1;
}
void SetWorldChangeMode(WorldChangeSystem::enumWorldChangeSystemMode mode)
{
static int setTime=0;
if(mode == WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_CHECK)
{
if ( g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode == WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE) return;
if( timeGetTime() - setTime > 20000)
{
g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode = WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE;
g_input->MouseEnable(true);
g_input->KeyEnable(true);
}
return;
}
g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode = mode;
if ( mode == WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE)
{
g_input->MouseEnable(true);
g_input->KeyEnable(true);
}
else
{
setTime = timeGetTime();
g_input->MouseEnable(false);
g_input->KeyEnable(false);
}
}
void GTH_ProcessMessage_ClearWorldChageMode()
{
g_cgv.myCharacterInfo->m_WorldChageSystem.m_SystemMode =
WorldChangeSystem::enumWorldChangeSystemMode::WORLD_CHANGESYSTEM_NONE;
g_input->MouseEnable(true);
g_input->KeyEnable(true);
} | C++ |
#include "../global_def.h"
NewDanBattleSystem::NewDanBattleSystem()
{
m_bActive = TRUE;
m_nMinPcCount = 0;
m_nBattleTimeForMin1 = 0;
m_nBattleTimeForMin2 = 0;
m_fItemDropRate = 1.0f;
m_EffectFlag = 0;
for (INT typeidx =0; typeidx < noticetype::max_notice; typeidx++)
memset(&m_notice[typeidx], 0x00, sizeof(sNoticeMsg));
}
void NewDanBattleSystem::InitDanBattleInfo()
{
m_nMinPcCount = 0;
m_nBattleTimeForMin1 = 0;
m_nBattleTimeForMin2 = 0;
m_fItemDropRate = 1.0f;
m_EffectFlag = 0;
memset(&m_DanBattleInfo, 0x00, sizeof(DanBattleInfo));
m_DanBattleInfo.AcceptDanInfo.nDanIdx = -1;
m_DanBattleInfo.RequestDanInfo.nDanIdx = -1;
m_DanBattleInfo.nDanBattleIdx = -1;
m_DanBattleInfo.nBattleMapIdx = -1;
g_NewDanBattleSystem.v_EffectPC.clear();
}
NewDanBattleSystem::~NewDanBattleSystem()
{
}
void NewDanBattleSystem::Update()
{
switch ( m_DanBattleInfo.BattleStatus )
{
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_NONE:
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_READY:
BattleReady();
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE:
Battle();
break;
case DanBattleInfo::enumBattleStatus::BATTLESTATUS_END:
BattleEnd();
break;
}
}
void NewDanBattleSystem::BattleReady()
{
if ( m_DanBattleInfo.fWaitTImeForReady > 0.0f ){
m_DanBattleInfo.fWaitTImeForReady -= g_timer.GetElapsedMilliTime();
}
ShoeEffectCount(m_DanBattleInfo.fWaitTImeForReady);
}
void NewDanBattleSystem::Battle()
{
if ( m_DanBattleInfo.fRemainSec > 0.0f ){
m_DanBattleInfo.fRemainSec -= g_timer.GetElapsedMilliTime();
}
ShoeEffectCount(m_DanBattleInfo.fRemainSec);
}
void NewDanBattleSystem::BattleEnd()
{
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetMyDanBattleInfo()
{
if ( m_DanBattleInfo.RequestDanInfo.nDanIdx == g_cgv.myCharacterInfo->guildIdx)
return &(m_DanBattleInfo.RequestDanInfo);
else
return &(m_DanBattleInfo.AcceptDanInfo);
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetDestDanBattleInfo()
{
if ( m_DanBattleInfo.RequestDanInfo.nDanIdx != g_cgv.myCharacterInfo->guildIdx)
return &(m_DanBattleInfo.RequestDanInfo);
else
return &(m_DanBattleInfo.AcceptDanInfo);
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetRequestDanBattleInfo()
{
return &(m_DanBattleInfo.RequestDanInfo);
}
NewDanBattleSystem::DanBaseInfo* NewDanBattleSystem::GetAcceptDanBattleInfo()
{
return &(m_DanBattleInfo.AcceptDanInfo);
}
NewDanBattleSystem::DanBattleInfo* NewDanBattleSystem::GetDanBattleInfo()
{
return &m_DanBattleInfo;
}
VOID NewDanBattleSystem::ShoeEffectCount(INT RemainTime)
{
UINT RemainMin = RemainTime/60000;
UINT RemainnSec = (RemainTime%60000) / 1000;
ShowLogInfo("RemainMin = %d, RemainSec = %d, danflag=%d",
RemainMin, RemainnSec, m_DanBattleInfo.BattleStatus);
UINT MaxCheckCount = 0;
UINT MinCheckCount = 0;
int NowEffectID = 0;
if ( m_DanBattleInfo.BattleStatus == DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE){
MaxCheckCount = 10;
MinCheckCount = 0;
NowEffectID = 64-(RemainnSec);
}
else{
MaxCheckCount = 11;
MinCheckCount = 1;
NowEffectID = 64-(RemainnSec-1);
}
if ( (RemainnSec >= MinCheckCount && RemainnSec <= MaxCheckCount) && RemainMin == 0 )
{
if ( m_EffectFlag & (1 << NowEffectID) )
return ;
char szMessage[256];
if (m_DanBattleInfo.BattleStatus == DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE)
{
if (NowEffectID == 64)
return;
_snprintf(szMessage, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 596), RemainnSec);
szMessage[256-1] = NULL;
g_ifMng->AddSysMessage(szMessage, GTHCOLOR_WORLDMESSAGE);
_snprintf(szMessage, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 597), RemainnSec);
szMessage[256-1] = NULL;
AddDanBattleNoticeMsg(szMessage, GTHCOLOR_ERRORMESSAGE);
}
else
{
if (NowEffectID == 64)
{
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( 44 ), GTH_SOUND_PLAY_ONCE );
m_EffectFlag |= 1 << NowEffectID;
return;
}
_snprintf(szMessage, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 598), RemainnSec -1);
szMessage[256-1] = NULL;
g_ifMng->AddSysMessage(szMessage, GTHCOLOR_WORLDMESSAGE);
}
g_effectMng->AddSelfEffect( GTH_EFFECT_CLASS_MODEL, (NowEffectID),
g_pApp->m_myCharacter->position,
NULL, true,
g_pApp->m_myCharacter->entityType,
g_pApp->m_myCharacter->idxOnServer,
0.0f, 0.0f, 0.0f, -1.0f,
false );
if ( NowEffectID == 54)
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( 45 ), GTH_SOUND_PLAY_ONCE );
m_EffectFlag |= 1 << NowEffectID;
ShowLogInfo("RemainMin = %d, RemainSec = %d", RemainMin, RemainnSec);
}
}
void NewDanBattleSystem::SetDanBattleStatus(DanBattleInfo::enumBattleStatus status)
{
m_DanBattleInfo.BattleStatus = status;
}
BOOL NewDanBattleSystem::IsDanBattleEnemy(int pcidx)
{
if ( (g_pApp->m_myCharacter->worldIdx == 0) ||
(g_pApp->m_myCharacter->worldIdx == 9) )
return FALSE;
if ( g_cgv.syncCharacter[0].worldIdx != m_DanBattleInfo.nBattleMapIdx )
return FALSE;
if ( pcidx < 0 || pcidx >= MAX_CHARACTERS)
return FALSE;
if ( m_DanBattleInfo.BattleStatus != DanBattleInfo::enumBattleStatus::BATTLESTATUS_BATTLE)
return FALSE;
if ( g_cgv.syncCharacter[pcidx].nDanBattleIdx < 0 )
return FALSE;
if ( g_cgv.syncCharacter[pcidx].entityType != ENTITY_PC)
return FALSE;
if ( g_cgv.syncCharacter[pcidx].nDanBattleIdx !=
g_cgv.syncCharacter[0].nDanBattleIdx)
return FALSE;
if ( g_cgv.syncCharacter[pcidx].guildIdx == g_cgv.syncCharacter[0].guildIdx)
return FALSE;
return TRUE;
}
void NewDanBattleSystem::AddDanBattleNoticeMsg( char* message, DWORD color, noticetype type)
{
if ( type <0 || type >= noticetype::max_notice)
return;
memset(&m_notice[type], 0x00, sizeof(sNoticeMsg));
m_notice[type].m_noticeColor = color;
m_notice[type].m_noticeTime = g_timer.GetAppMilliTime();
strncpy(m_notice[type].m_noticeMsg, message, 256);
m_notice[type].m_noticeMsg[255] = NULL;
}
void NewDanBattleSystem::RenderDanBattle_Notice(void)
{
g_chatManager->SetZPos();
g_chatManager->SetWPos();
for (int nNoticeidx = 0; nNoticeidx <max_notice; nNoticeidx++)
{
if( m_notice[nNoticeidx].m_noticeTime + 8000.0f > g_timer.GetAppMilliTime() &&
m_notice[nNoticeidx].m_noticeMsg[0] != 0 )
{
int x =0, y = 0;
int size = 0;
switch(nNoticeidx)
{
case noticetype::notice:
{
y = 55;
size = g_chatManager->GetChatStrSizeChat( m_notice[nNoticeidx].m_noticeMsg );
x = g_ifMng->m_clientWidth / 2 - size / 2;
}
break;
case noticetype::killpoint_notice:
{
y = g_ifMng->m_iPos[IF_HOT_WIN].clientY - g_ifMng->m_iPos[IF_HOT_WIN].sizeY - 20;
x = 5;
}
break;
case noticetype::plunder_notice:
{
y = g_ifMng->m_iPos[IF_HOT_WIN].clientY - g_ifMng->m_iPos[IF_HOT_WIN].sizeY;
x = 5;
}
break;
}
g_chatManager->SetColor( m_notice[nNoticeidx].m_noticeColor );
g_chatManager->Output( x, y + 17, m_notice[nNoticeidx].m_noticeMsg, true );
}
}
}
| C++ |
#include "../global_def.h"
void SetItemSpawnType(item_t *pItem, ITEM_SPAWN_INFO::enumItemSpawnType type)
{
pItem->ItemExtendInfo.ItemSpawnInfomation.ItemSpawnType = type;
}
ITEM_SPAWN_INFO::enumItemSpawnType GetItemSpawnType(const item_t *pItem)
{
return pItem->ItemExtendInfo.ItemSpawnInfomation.ItemSpawnType;
}
void SetItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag)
{
pItem->ItemExtendInfo.UseFlag |= flag;
}
BOOL IsItemUseFlag(item_t *pItem, ENUM_ITEM_USE_FLAG flag)
{
if ( pItem->ItemExtendInfo.UseFlag & flag)
return TRUE;
return FALSE;
}
| C++ |
#include "../global_def.h"
char *curpos, *endpos;
byte *g_tokenBuffer = NULL;
FILE *g_tokenFileBuffer;
int SetTokenBuffer( byte *buffer , int size )
{
curpos = (char *)buffer;
endpos = curpos + size;
if( size <= 0 )
return false;
return true;
}
char* NextToken()
{
char *token;
while (curpos < endpos)
{
while (*curpos == ' ' || *curpos == '\t' || *curpos == '\n' || *curpos == '\r')
if (++curpos == endpos) return NULL;
if (curpos[0] == '/' && curpos[1] == '/')
{
while (*curpos++ != '\n')
if (curpos == endpos) return NULL;
continue;
}
token = curpos;
while (*curpos != ' ' && *curpos != '\t' && *curpos != '\n' && *curpos != '\r')
if (++curpos == endpos) break;
*curpos++ = '\0';
return token;
}
return NULL;
}
char* NextArg()
{
char *arg;
while (curpos < endpos)
{
while (*curpos == ' ' || *curpos == '\t')
if (++curpos == endpos) return NULL;
if( *curpos == '\n' || *curpos == '\r' ||
(curpos[0] == '/' && curpos[1] == '/') )
return NULL;
arg = curpos;
while (*curpos != ' ' && *curpos != '\t' && *curpos != '\n' && *curpos != '\r')
if (++curpos == endpos) break;
*curpos++ = '\0';
return arg;
}
return NULL;
}
int BeginTokenScript( char* filename )
{
int size;
g_tokenFileBuffer = fopen( filename , "rb" );
if( !g_tokenFileBuffer )
{
return false;
}
fseek(g_tokenFileBuffer,0,SEEK_END);
size = ftell(g_tokenFileBuffer);
g_tokenBuffer = new byte[size];
fseek(g_tokenFileBuffer,0,SEEK_SET);
fread(g_tokenBuffer,size,1,g_tokenFileBuffer);
fclose(g_tokenFileBuffer);
curpos = (char *)g_tokenBuffer;
endpos = curpos + size;
return( true );
}
void EndTokenScript()
{
if( g_tokenBuffer != NULL ) delete g_tokenBuffer;
}
| C++ |
#include "../global_def.h"
gthconfig_t g_lowQualityConfig;
gthconfig_t g_highQualityConfig;
gthconfig_t g_userConfig;
int GTH_Setup_LoadConfig( char* filename )
{
char* token;
memset( &g_userConfig, 0, sizeof( gthconfig_t ) );
g_userConfig.isLoaded = false;
if( !BeginTokenScript( filename ) ) return 0;
while( 1 )
{
token = NextToken();
if( token == NULL ) break;
if( !stricmp( token, "u_resolution" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.resoution = atoi( token );
} else if( !stricmp( token, "u_texture" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.texture = atoi( token );
} else if( !stricmp( token, "u_shadow" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.shadow = atoi( token );
} else if( !stricmp( token, "u_vision" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.vision = atoi( token );
} else if( !stricmp( token, "u_fog" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.fog = atoi( token );
} else if( !stricmp( token, "u_window" ) )
{
g_userConfig.isLoaded = true;
token = NextToken();
g_userConfig.window = atoi( token );
}
}
EndTokenScript();
return 1;
}
void GTH_Setup_SaveConfig( char* filename )
{
FILE *fp;
fp = fopen( filename, "w" );
fprintf( fp, "// gth client config\n" );
fprintf( fp, "// resolution\n" );
fprintf( fp, "// 0 : 1024x768x16, 1 : 1280x1024x16\n" );
fprintf( fp, "// texture\n" );
fprintf( fp, "// 0 : high, 1 : low\n" );
fprintf( fp, "// shadow\n" );
fprintf( fp, "// 0 : on, 1 : off\n" );
fprintf( fp, "// vision\n" );
fprintf( fp, "// 0 : high, 1 : low\n" );
fprintf( fp, "// fog\n" );
fprintf( fp, "// 0 : on, 1 : off\n" );
fprintf( fp, "// window\n" );
fprintf( fp, "// 0 : on, 1 : off\n" );
fprintf( fp, "\n\n" );
fprintf( fp, "// auto config low quality\n" );
fprintf( fp, "l_resolution\t\t%d\n", g_lowQualityConfig.resoution );
fprintf( fp, "l_texture\t\t%d\n", g_lowQualityConfig.texture );
fprintf( fp, "l_shadow\t\t%d\n", g_lowQualityConfig.shadow );
fprintf( fp, "l_vision\t\t%d\n", g_lowQualityConfig.vision );
fprintf( fp, "l_fog\t\t%d\n\n\n", g_lowQualityConfig.fog );
fprintf( fp, "l_window\t\t%d\n", g_lowQualityConfig.window );
fprintf( fp, "// auto config high quality\n" );
fprintf( fp, "h_resolution\t\t%d\n", g_highQualityConfig.resoution );
fprintf( fp, "h_texture\t\t%d\n", g_highQualityConfig.texture );
fprintf( fp, "h_shadow\t\t%d\n", g_highQualityConfig.shadow );
fprintf( fp, "h_vision\t\t%d\n", g_highQualityConfig.vision );
fprintf( fp, "h_fog\t\t%d\n\n\n", g_highQualityConfig.fog );
fprintf( fp, "h_window\t\t%d\n\n\n", g_highQualityConfig.window );
fprintf( fp, "// user config\n" );
fprintf( fp, "u_resolution\t\t%d\n", g_userConfig.resoution );
fprintf( fp, "u_texture\t\t%d\n", g_userConfig.texture );
fprintf( fp, "u_shadow\t\t%d\n", g_userConfig.shadow );
fprintf( fp, "u_vision\t\t%d\n", g_userConfig.vision );
fprintf( fp, "u_fog\t\t%d\n", g_userConfig.fog );
fprintf( fp, "u_window\t\t%d\n\n\n", g_userConfig.window );
fclose( fp );
}
| C++ |
#include "../global_def.h"
void GTH_DecodeCashMallItem()
{
SHORT Packet = static_cast<enum enumPacketCashMallItem>(MSG_ReadShort());
switch(Packet)
{
case REPLY_USE_STONE_OF_SAGE:
GTH_ProcessMessageReply_StoneOfSage();
break;
case REPLY_USE_STONE_OF_LUCKY:
GTH_ProcessMessageReply_StoneOfLucky();
break;
case REPLY_USE_STONE_OF_EACH_NAME:
GTH_ProcessMessageReply_StoneOfEachName();
break;
case REPLY_USE_REVERSE_OF_MEMORY:
GTH_ProcessMessageReply_ReverseOfMemory();
break;
case REPLY_OPTION_ITEM_EDIT:
GTH_ProcessMessageReply_OptionItemEdit();
break;
case REPLY_OPTION_ITEM_WINCLOSE:
GTH_ProcessMessageReply_OptionItemWinClose();
break;
case REPLY_OPTION_ITEM_MODIFY:
GTH_ProcessMessageReply_ItemModify();
break;
}
}
void GTH_ProcessMessageReply_StoneOfSage()
{
BOOL Reply = -1;
Reply = MSG_ReadLong();
if ( Reply == TRUE)
{
g_ifMng->m_CashMallItem->InitCashMallItem();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx = MSG_ReadLong();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_CashMallItem_DestroyRate = MSG_ReadFloat();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_CashMallItem_SuccecsRate = MSG_ReadFloat();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE;
g_ifMng->m_CashMallItem->Enable();
CIFItemWin::sLockItem lockitem;
lockitem.nInvenPos = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
if ( lockitem.nInvenPos >= 0 || lockitem.nInvenPos < MAX_INVENTORY_SIZE)
{
int nitemIdx = g_cgv.myCharacterInfo->inventory[lockitem.nInvenPos];
if ( nitemIdx >= 0 || nitemIdx < MAX_NUMBER_OF_OWNITEM )
{
item_t* pItem = &g_cgv.myCharacterInfo->item[nitemIdx];
lockitem.nItemTableIdx = pItem->itemTableIdx;
g_ifMng->m_itemWin->LockItem(lockitem);
}
}
}
else
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
}
}
void GTH_ProcessMessageReply_StoneOfLucky()
{
BOOL Reply = -1;
Reply = MSG_ReadLong();
if ( Reply == TRUE)
{
g_ifMng->m_CashMallItem->InitCashMallItem();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
int InvenPos = MSG_ReadLong();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx= InvenPos;
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_CashMallItem_DestroyRate = MSG_ReadFloat();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_CashMallItem_SuccecsRate= MSG_ReadFloat();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY;
g_ifMng->m_CashMallItem->Enable();
CIFItemWin::sLockItem lockitem;
lockitem.nInvenPos = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
if ( lockitem.nInvenPos >= 0 || lockitem.nInvenPos < MAX_INVENTORY_SIZE)
{
int nitemIdx = g_cgv.myCharacterInfo->inventory[lockitem.nInvenPos];
if ( nitemIdx >= 0 || nitemIdx < MAX_NUMBER_OF_OWNITEM )
{
item_t* pItem = &g_cgv.myCharacterInfo->item[nitemIdx];
lockitem.nItemTableIdx = pItem->itemTableIdx;
g_ifMng->m_itemWin->LockItem(lockitem);
}
}
}
else
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
}
}
void GTH_ProcessMessageReply_StoneOfEachName()
{
BOOL Reply = -1;
Reply = MSG_ReadLong();
if ( Reply == TRUE)
{
g_ifMng->m_CashMallItem->InitCashMallItem();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.InitCashMallItem_OptionStone();
int InvenPos = MSG_ReadLong();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx= InvenPos;
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemMode =
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME;
g_ifMng->m_CashMallItem->Enable();
CIFItemWin::sLockItem lockitem;
lockitem.nInvenPos = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx;
if ( lockitem.nInvenPos >= 0 || lockitem.nInvenPos < MAX_INVENTORY_SIZE)
{
int nitemIdx = g_cgv.myCharacterInfo->inventory[lockitem.nInvenPos];
if ( nitemIdx >= 0 || nitemIdx < MAX_NUMBER_OF_OWNITEM )
{
item_t* pItem = &g_cgv.myCharacterInfo->item[nitemIdx];
lockitem.nItemTableIdx = pItem->itemTableIdx;
g_ifMng->m_itemWin->LockItem(lockitem);
}
}
}
else
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
}
}
void GTH_ProcessMessageReply_ReverseOfMemory()
{
BOOL Reply = -1;
Reply = MSG_ReadLong();
if ( Reply == TRUE)
{
int ItemPos = MSG_ReadLong();
GTH_UseItem_Delete(ItemPos);
g_cgv.myCharacterInfo->pcJob = MSG_ReadLong();
for (int idx = 0; idx < GEN_NUMBER; idx ++)
g_cgv.myCharacterInfo->genCapability[idx] = MSG_ReadLong();
for (idx = 0; idx < MAX_NUMBER_OF_HOTKEY; idx ++)
{
g_cgv.myCharacterInfo->hotkeyType[idx] = MSG_ReadLong();
g_cgv.myCharacterInfo->hotkeyIdx[idx] = MSG_ReadLong();
}
int InitSKillNumber = MSG_ReadLong();
for (idx = 0; idx < InitSKillNumber; idx++)
g_SkillLogic.GTH_DeleteSKill(MSG_ReadLong());
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 507));
}
else
{
enum enumCashMallItem_Error Error = static_cast<enum enumCashMallItem_Error>(MSG_ReadLong());
switch(Error)
{
case CASHMALL_ITEM_ERROR_0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 508));
break;
case CASHMALL_ITEM_ERROR_1:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 509));
break;
case CASHMALL_ITEM_ERROR_2:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
break;
case CASHMALL_ITEM_ERROR_3:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 510));
break;
case CASHMALL_ITEM_ERROR_4:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 511));
break;
case CASHMALL_ITEM_ERROR_5:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 512));
break;
}
}
}
void GTH_ProcessMessageReply_OptionItemEdit()
{
BOOL bError = MSG_ReadLong();
if( bError == FALSE )
{
g_cgv.myCharacterInfo->mouseInventory = MSG_ReadLong();
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx = MSG_ReadLong();
if ( g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx != -1)
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_EQUIP_ITEM ), GTH_SOUND_PLAY_ONCE );
else
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_ITEM_CLICK_2 ), GTH_SOUND_PLAY_ONCE );
g_ifMng->m_CashMallItem->SortItemOptionList();
}
else
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322), g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 269));
}
}
void GTH_SendMessageRequest_StoneOfSage(const int InvenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_USE_STONE_OF_SAGE );
MSG_WriteLong(&netMessage, InvenPos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequest_StoneOfLucky(const int InvenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_USE_STONE_OF_LUCKY );
MSG_WriteLong(&netMessage, InvenPos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequest_StoneOfEachName(const int InvenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_USE_STONE_OF_EACH_NAME );
MSG_WriteLong(&netMessage, InvenPos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequest_ReverseOfMemory(const int InvenPos)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_USE_REVERSE_OF_MEMORY );
MSG_WriteLong(&netMessage, InvenPos);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequest_OptionItemEdit()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_OPTION_ITEM_EDIT );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessageReply_OptionItemWinClose()
{
BOOL bError = MSG_ReadLong();
g_ifMng->m_CashMallItem->InitCashMallItem();
g_ifMng->m_CashMallItem->Enable(FALSE);
g_ifMng->m_itemWin->ClearLockItems();
if( bError == FALSE )
{
item_t *pSrcitem;
int itemIdx, inventoryPos;
itemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
if(itemIdx < 0)
return;
pSrcitem = &g_cgv.myCharacterInfo->item[itemIdx];
int stackItemIdx = GTH_StackMyItem(pSrcitem);
if(stackItemIdx >= 0)
{
g_cgv.myCharacterInfo->item[stackItemIdx].durability += pSrcitem->durability+1;
if( g_cgv.myCharacterInfo->item[stackItemIdx].durability >= MAX_COUNT_STACK_ITEM )
g_cgv.myCharacterInfo->item[stackItemIdx].durability = MAX_COUNT_STACK_ITEM - 1;
GTH_DeleteMyItem( pSrcitem );
}
else
{
inventoryPos = GTH_FindEmptyInventoryPos();
if( inventoryPos >= 0 )
g_cgv.myCharacterInfo->inventory[inventoryPos] = itemIdx;
else
GTH_DeleteMyItem( pSrcitem );
}
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_EQUIP_ITEM ), GTH_SOUND_PLAY_ONCE );
}
else
{
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
}
}
void GTH_SendMessageRequest_OptionItemWinClose()
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_OPTION_ITEM_WINCLOSE );
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_SendMessageRequest_ItemModify(CashMallItem_OptionStone::enumUseItemMode mode, int SelectOptionIdx)
{
MSG_BeginWriting( &netMessage );
MSG_Clear( &netMessage );
{
MSG_WriteByte(&netMessage, EXTEND_SECOND);
MSG_WriteShort(&netMessage, CASH_MALL_ITEM );
MSG_WriteShort(&netMessage, REQUEST_OPTION_ITEM_MODIFY );
MSG_WriteLong(&netMessage, (int)mode);
if ( mode != CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY)
MSG_WriteLong(&netMessage, SelectOptionIdx);
NET_SendMessage(&gsSocket, &netMessage);
}
MSG_EndWriting(&netMessage);
}
void GTH_ProcessMessageReply_ItemModify()
{
CashMallItem_OptionStone::enumUseItemMode mode;
mode = static_cast<enum CashMallItem_OptionStone::enumUseItemMode> (MSG_ReadLong());
switch(mode)
{
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE:
GTH_ProcessMessageReply_ItemModify_Stone_Of_Sage();
break;
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_LUCKY:
GTH_ProcessMessageReply_ItemModify_Stone_Of_lucky();
break;
case CashMallItem_OptionStone::enumUseItemMode::STONE_OF_EACH_NAME:
GTH_ProcessMessageReply_ItemModify_Stone_Of_EachName();
break;
}
}
void GTH_ProcessMessageReply_ItemModify_Stone_Of_Sage()
{
BOOL Reply = FALSE;
Reply = MSG_ReadLong();
if ( Reply == TRUE )
{
item_t *pItem = NULL;
int ItemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
if ( ItemIdx < 0 || ItemIdx >= MAX_NUMBER_OF_OWNITEM)
return;
pItem = &g_cgv.myCharacterInfo->item[ItemIdx];
char szOptionText[256];
char szMsg[256];
g_ifMng->m_CashMallItem->GetItemOptionString(szOptionText, 256,
g_ifMng->m_CashMallItem->m_OptionArryIdx);
MSG_ReadItem( pItem );
g_ifMng->m_CashMallItem->SortItemOptionList();
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_GEN_CLICK ),
GTH_SOUND_PLAY_ONCE );
char szOptionText2[256];
g_ifMng->m_CashMallItem->GetItemOptionString(szOptionText2, 256,
g_ifMng->m_CashMallItem->m_OptionArryIdx);
_snprintf( szMsg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 513), szOptionText, szOptionText2);
szMsg[255] = NULL;
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), szMsg, MSG_BUTTONTYPE_OK,
IF_MESSAGE_MODIFY_OPTION_SUCCECS);
GTH_UseItem_Delete(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx);
}
else
{
enum enumCashMallItem_Error Error = static_cast<enum enumCashMallItem_Error>(MSG_ReadLong());
switch(Error)
{
case CASHMALL_ITEM_ERROR_0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
break;
case CASHMALL_ITEM_ERROR_1:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 514));
break;
case CASHMALL_ITEM_ERROR_2:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 515));
break;
case CASHMALL_ITEM_ERROR_3:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 510));
break;
case CASHMALL_ITEM_ERROR_4:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 529));
break;
case CASHMALL_ITEM_ERROR_5:
GTH_ItemModify_DestroyItem();
break;
case CASHMALL_ITEM_ERROR_6:
GTH_ItemModify_FailedItem();
case CASHMALL_ITEM_ERROR_7:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 556));
break;
break;
default:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 516));
}
}
}
void GTH_ItemModify_DestroyItem()
{
int OptionItemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
item_t *pItem = NULL;
if ( OptionItemIdx >= 0 || OptionItemIdx < MAX_NUMBER_OF_OWNITEM)
{
pItem = &g_cgv.myCharacterInfo->item[OptionItemIdx];
if ( pItem != NULL)
GTH_DeleteMyItem( pItem );
}
GTH_UseItem_Delete(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx);
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx = -1;
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx = -1;
g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_CashMallItem_DestroyRate = 0.0f;
memset(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iSortOptionIdx, -1, MAX_NUMBER_OF_ITEM_OPTION);
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 517), MSG_BUTTONTYPE_OK, IF_MESSAGE_MODIFY_ITEM_DESTROY);
}
void GTH_ProcessMessageReply_ItemModify_Stone_Of_lucky()
{
BOOL Reply = FALSE;
Reply = MSG_ReadLong();
if ( Reply == TRUE )
{
item_t *pItem = NULL;
int ItemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
if ( ItemIdx < 0 || ItemIdx >= MAX_NUMBER_OF_OWNITEM)
return;
pItem = &g_cgv.myCharacterInfo->item[ItemIdx];
MSG_ReadItem( pItem );
char szOptionText[256];
char szMsg[256];
g_ifMng->m_CashMallItem->GetItemOptionString(szOptionText, 256,
pItem->optionNumber-1 );
g_ifMng->m_CashMallItem->SortItemOptionList();
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_GEN_CLICK ),
GTH_SOUND_PLAY_ONCE );
_snprintf( szMsg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 518), szOptionText);
szMsg[255] = NULL;
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), szMsg, MSG_BUTTONTYPE_OK,
IF_MESSAGE_MODIFY_OPTION_SUCCECS);
GTH_UseItem_Delete(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx);
}
else
{
enum enumCashMallItem_Error Error = static_cast<enum enumCashMallItem_Error>(MSG_ReadLong());
switch(Error)
{
case CASHMALL_ITEM_ERROR_0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
break;
case CASHMALL_ITEM_ERROR_1:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 514));
break;
case CASHMALL_ITEM_ERROR_2:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 515));
break;
case CASHMALL_ITEM_ERROR_3:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 510));
break;
case CASHMALL_ITEM_ERROR_4:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 529));
break;
case CASHMALL_ITEM_ERROR_5:
GTH_ItemModify_DestroyItem();
break;
case CASHMALL_ITEM_ERROR_6:
GTH_ItemModify_FailedItem();
break;
case CASHMALL_ITEM_ERROR_7:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 555));
break;
default:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 516));
}
}
}
void GTH_ProcessMessageReply_ItemModify_Stone_Of_EachName()
{
BOOL Reply = FALSE;
Reply = MSG_ReadLong();
if ( Reply == TRUE )
{
item_t *pItem = NULL;
int ItemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
if ( ItemIdx < 0 || ItemIdx >= MAX_NUMBER_OF_OWNITEM)
return;
pItem = &g_cgv.myCharacterInfo->item[ItemIdx];
char szOptionText[256];
char szMsg[256];
g_ifMng->m_CashMallItem->GetItemOptionString(szOptionText, 256,
g_ifMng->m_CashMallItem->m_OptionArryIdx);
MSG_ReadItem( pItem );
g_ifMng->m_CashMallItem->SortItemOptionList();
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_GEN_CLICK ),
GTH_SOUND_PLAY_ONCE );
_snprintf( szMsg, 256, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 520), szOptionText);
szMsg[255] = NULL;
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), szMsg, MSG_BUTTONTYPE_OK,
IF_MESSAGE_MODIFY_OPTION_SUCCECS);
GTH_UseItem_Delete(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx);
}
else
{
enum enumCashMallItem_Error Error = static_cast<enum enumCashMallItem_Error>(MSG_ReadLong());
switch(Error)
{
case CASHMALL_ITEM_ERROR_0:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 506));
break;
case CASHMALL_ITEM_ERROR_1:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 514));
break;
case CASHMALL_ITEM_ERROR_2:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 515));
break;
case CASHMALL_ITEM_ERROR_3:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 510));
break;
case CASHMALL_ITEM_ERROR_4:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 529));
break;
case CASHMALL_ITEM_ERROR_5:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 519));
break;
default:
g_ifMng->SetMessage(g_LPACK.GetMassage(LPACK_TYPE_NORMAL, 322),
g_LPACK.GetMassage(LPACK_TYPE_NORMAL2, 516));
}
}
}
void GTH_ItemModify_FailedItem(void)
{
item_t *pItem = NULL;
int ItemIdx = g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iEditOptionItemIdx;
if ( ItemIdx < 0 || ItemIdx >= MAX_NUMBER_OF_OWNITEM)
return;
pItem = &g_cgv.myCharacterInfo->item[ItemIdx];
g_musicMng->PlaySample( g_soundMng->GetNormalSoundID( GTH_SOUND_ID_GEN_CLICK ),
GTH_SOUND_PLAY_ONCE );
if ( g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemMode ==
CashMallItem_OptionStone::enumUseItemMode::STONE_OF_SAGE)
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 558 ), MSG_BUTTONTYPE_OK,
IF_MESSAGE_MODIFY_OPTION_SUCCECS);
}
else
{
g_ifMng->SetMessage( g_LPACK.GetMassage( 0, 322 ), g_LPACK.GetMassage( LPACK_TYPE_NORMAL2, 557 ), MSG_BUTTONTYPE_OK,
IF_MESSAGE_MODIFY_OPTION_SUCCECS);
}
GTH_UseItem_Delete(g_cgv.myCharacterInfo->m_CashMall_OptionStone.m_iUsingItemInvenIdx);
} | C++ |
#include "global_def.h"
#include "resource.h"
#include "GTH.h"
#include "../game/GolryunBattle/GolryunBattle.h"
VOID GTH::ReadSettings()
{
HKEY hkey;
if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, DXAPP_KEY,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
{
DXUtil_ReadIntRegKey( hkey, TEXT("Width"), &m_dwCreationWidth, m_dwCreationWidth );
DXUtil_ReadIntRegKey( hkey, TEXT("Height"), &m_dwCreationHeight, m_dwCreationHeight );
RegCloseKey( hkey );
}
}
VOID GTH::WriteSettings()
{
HKEY hkey;
DWORD dwType = REG_DWORD;
DWORD dwLength = sizeof(DWORD);
if( ERROR_SUCCESS == RegCreateKeyEx( HKEY_CURRENT_USER, DXAPP_KEY,
0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ) )
{
DXUtil_WriteIntRegKey( hkey, TEXT("Width"), m_rcWindowClient.right );
DXUtil_WriteIntRegKey( hkey, TEXT("Height"), m_rcWindowClient.bottom );
RegCloseKey( hkey );
}
}
HRESULT GTH::ConfirmDevice( D3DCAPS8* pCaps, DWORD dwBehavior,
D3DFORMAT Format )
{
BOOL bCapsAcceptable;
bCapsAcceptable = TRUE;
if( bCapsAcceptable )
return S_OK;
else
return E_FAIL;
}
extern int totalPacketsSend;
extern int totalPacketsReceived;
extern int packetsSent;
extern int packetsReceived;
extern int packetsReSent;
extern int packetsDropCount;
extern int packetsDupCount;
extern int packetsAckSent;
extern int packetsAckReceived;
extern int un_packetsSent;
extern int un_packetsReceived;
extern int un_packetsDropCount;
extern int lastRecvSequence;
extern int myRecvSequence;
HRESULT GTH::RenderText()
{
if ( ! g_pApp ->m_renderEnabled )
return S_OK;
int i;
float sum, fps;
vec3_t svrPosition;
g_chatManager->SetFontColor( 0xffffffff );
g_chatManager->SetDFontColor( 0xffffffff );
if ( !g_cgv.displayDebugMessage ) return S_OK;
if( !GTH_IsGameMaster( g_pApp->m_myCharacter ) ) return S_OK;
g_chatManager->SetFontSize( 12.0f );
g_chatManager->DPrint( 2, 20, m_strDeviceStats );
g_chatManager->DPrint( 2, 40, m_strFrameStats );
extern itementity_t *g_mouseSelectedItemObject;
if( g_mouseSelectedItemObject )
g_chatManager->DPrint( 2, 140, "serverID : %d IDX : %d" , g_mouseSelectedItemObject->idxOnServer , g_mouseSelectedItemObject->idx );
extern Fx_CHARACTER_t *g_mouseSelectedCharacter;
if( g_mouseSelectedCharacter )
{
g_chatManager->HPrint( 2, 160, "serverID : %d name : %s" , g_mouseSelectedCharacter->idxOnServer , g_mouseSelectedCharacter->name );
g_chatManager->HPrint( 2, 180, "pos(%.2f,%.2f,%.2f)", g_mouseSelectedCharacter->position[0],
g_mouseSelectedCharacter->position[1], g_mouseSelectedCharacter->position[2] );
}
g_chatManager->SetOutputType( CHAT_OUTPUT_BORDER );
g_chatManager->HPrint( 2, 60, "camPos : %10.4f %10.4f %10.4f , %d %d" , g_camera.m_position[0] , g_camera.m_position[1] , g_camera.m_position[2] , m_worldBSPs[ m_currWorld ]->m_totalRenderPolygon , m_MDLMng->m_totalRenderPolygon );
g_chatManager->DPrint( 2, 80, "time : %10.6f %10.6f %10.6f %10.6f %10.6f %10.6f" , check.time0 , check.time1 , check.time2 , check.time3 , check.time4 , check.time5 );
g_chatManager->DPrint( 2, 100, "time : %10.6f %10.6f %10.6f %10.6f %10.6f" , check.time6 , check.time7 , check.time8 , check.time9 , check.time10 );
sum = check.time0 + check.time1 + check.time2 + check.time3 + check.time4 + check.time5
+ check.time6 + check.time7 + check.time8 + check.time9 + check.time10;
fps = 1.0f / sum;
g_chatManager->DPrint( 2, 120, "time : %10.6f %10.6f fps " , sum , fps );
if ( g_cgv.displayDebugMessage )
{
g_chatManager->DPrint( 2, 140, "total send:%d, total recv:%d, send:%d, recv:%d, resend:%d, drop:%d, dup:%d",
totalPacketsSend, totalPacketsReceived,
packetsSent, packetsReceived, packetsReSent, packetsDropCount, packetsDupCount );
g_chatManager->DPrint( 2, 160, "acksend:%d, ackrecv:%d, un_send:%d, un_recv:%d, un_drop:%d",
packetsAckSent, packetsAckReceived, un_packetsSent, un_packetsReceived, un_packetsDropCount );
g_chatManager->DPrint( 2, 180, "LatencyTime: %d, character Number: %d", g_cgv.latencyTime, g_charManager->m_iNumCharacters);
g_chatManager->SetOutputType( CHAT_OUTPUT_NORMAL );
g_chatManager->HPrint( 2, 200, "event : %d, aniSetType : %d, aniItemSetIndex : %d, aniSetID: %d" , m_myCharacter->event, m_myCharacter->ani_curSetType, m_myCharacter->ani_curItemSetIndex, m_myCharacter->ani_curSetID);
g_chatManager->SetOutputType( CHAT_OUTPUT_SHADOW );
g_chatManager->HPrint( 2, 220, "Name: %s, RA: %d, SA: %d, Speed: %f", m_myCharacter->name, m_myCharacter->curRA, m_myCharacter->curSA, m_myCharacter->moveSpeed);
g_chatManager->DPrint( 2, 240, "Position: (%f, %f, %f), Yaw: %f", m_myCharacter->position[0], m_myCharacter->position[1], m_myCharacter->position[2], m_myCharacter->angles[ YAW ]);
g_chatManager->DPrint( 2, 260, "mycharacterYaw: %f, mouseAngle: %f", m_myCharacter->angles[ YAW ], m_myCharacter->mouseAngle);
svrPosition[0] = m_myCharacter->position[0] - m_worldBSPs[0]->m_models->bbox[0];
svrPosition[1] = m_myCharacter->position[1] - m_worldBSPs[0]->m_models->bbox[1];
svrPosition[2] = m_myCharacter->position[2] - m_worldBSPs[0]->m_models->bbox[2];
g_chatManager->DPrint( 2, 280, "Server Position: (%f, %f, %f)", svrPosition[0], svrPosition[1], svrPosition[2]);
g_chatManager->DPrint( 400, 280, "ChatManager Frame : %d, Vertex : %d", g_chatManager->m_frameFlag, g_chatManager->m_saveFrameFlag );
g_chatManager->SetOutputType( CHAT_OUTPUT_BORDER );
g_chatManager->HPrint( 2, 300, "Memory Info : MDL (%.2f/%.2f), Texture (%.2f/%.2f), Sound(%.2f/%.2f)",
(float)m_MDLMng->m_resManager.GetUsedMemory() * 0.001f, (float)m_MDLMng->m_resManager.GetMaximumMemory() * 0.001f,
(float)g_texMng.m_resManager.GetUsedMemory() * 0.001f, (float)g_texMng.m_resManager.GetMaximumMemory() * 0.001f,
(float)g_musicMng->m_resManager.GetUsedMemory() * 0.001f, (float)g_musicMng->m_resManager.GetMaximumMemory() * 0.001f );
for ( i=0; i<g_charManager->m_iNumCharacters; i++)
{
if ( g_charManager->m_Characters[i].entityType == ENTITY_PC)
g_chatManager->HPrint( 2, 340 + i * 20, "%s(%d) => RA: %d, Speed: %f", g_charManager->m_Characters[i].name, g_charManager->m_Characters[i].idxOnServer, g_charManager->m_Characters[i].curRA, g_charManager->m_Characters[i].moveSpeed);
else
g_chatManager->HPrint( 2, 340 + i * 20, "%s(%d) => RA: %d, Speed: %f",
g_charManager->m_Characters[i].name, g_charManager->m_Characters[i].idxOnServer, g_charManager->m_Characters[i].curRA, g_charManager->m_Characters[i].moveSpeed);
}
}
return S_OK;
}
INT GTH::Run()
{
HACCEL hAccel = LoadAccelerators( NULL, MAKEINTRESOURCE(IDR_MAIN_ACCEL) );
BOOL bGotMsg;
MSG msg;
msg.message = WM_NULL;
PeekMessage( &msg, NULL, 0U, 0U, PM_NOREMOVE );
while( WM_QUIT != msg.message && !m_bAppExit )
{
if( m_bActive )
bGotMsg = PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE );
else
bGotMsg = GetMessage( &msg, NULL, 0U, 0U );
if( bGotMsg )
{
if( 0 == TranslateAccelerator( m_hWnd, hAccel, &msg ) )
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
else
{
if( m_bActive && m_bReady )
{
if( FAILED( AppFrame() ) )
{
SendMessage( m_hWnd, WM_CLOSE, 0, 0 );
}
#ifdef _FMOD_SOUND
FSOUND_Update ();
#endif
}
}
}
Cleanup3DEnvironment();
return (INT)msg.wParam;
}
HRESULT GTH::BeginScene()
{
HRESULT hr;
if( FAILED( hr = m_pd3dDevice->TestCooperativeLevel() ) )
{
m_renderEnabled = false;
if( D3DERR_DEVICELOST == hr )
return S_OK;
if( D3DERR_DEVICENOTRESET == hr )
{
if( m_bWindowed )
{
D3DAdapterInfo* pAdapterInfo = &m_Adapters[m_dwAdapter];
m_pD3D->GetAdapterDisplayMode( m_dwAdapter, &pAdapterInfo->d3ddmDesktop );
m_d3dpp.BackBufferFormat = pAdapterInfo->d3ddmDesktop.Format;
}
if( FAILED( hr = Resize3DEnvironment() ) )
return hr;
}
return hr;
}
m_renderEnabled = true;
extern int g_freeMove;
if( g_freeMove )
{
m_pd3dDevice->Clear( 0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
0, 1.0f, 0L );
}
else
{
m_pd3dDevice->Clear(0L, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_COLORVALUE(0.5f, 0.5f, 0.6f, 1.0f), 1.0f, 0L);
}
if( FAILED( m_pd3dDevice->BeginScene() ) )
return hr;
return S_OK;
}
void GTH::EndScene()
{
m_pd3dDevice->EndScene();
static FLOAT fLastTime = 0.0f;
static DWORD dwFrames = 0L;
FLOAT fTime = g_timer.GetAppTime();
++dwFrames;
if( fTime - fLastTime > 1.0f )
{
m_fFPS = dwFrames / (fTime - fLastTime);
fLastTime = fTime;
dwFrames = 0L;
sprintf( m_strFrameStats, "%.2f", m_fFPS );
}
m_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
HRESULT GTH::OneTimeSceneInit()
{
g_timeSystem->OneTimeSceneInit();
g_timeSystem->SetDropperOrigin( &g_charManager->m_Characters [0].position [0] );
g_timeSystem->SetDropperCharHeight( &g_charManager->m_Characters [0].stat_height );
SendMessage( m_hWnd, WM_PAINT, 0, 0 );
m_bLoadingApp = FALSE;
return S_OK;
}
HRESULT GTH::InitDeviceObjects()
{
g_d3dDevice.SetD3DDevice(m_pd3dDevice);
if( !InitApp() )
return E_FAIL;
return S_OK;
}
HRESULT GTH::DeleteDeviceObjects()
{
int i;
switch( g_cgv.state )
{
case CLIENT_START_PROCESS :
case CLIENT_LOGIN_PROCESS :
case CLIENT_CHARACTER_PROCESS :
case CLIENT_LOADING_PROCESS :
case CLIENT_GAME_PROCESS :
for( i = 0 ; i < m_numWorldBSPs ; i++ )
GTH_SAFE_DELETE( m_worldBSPs[ i ] );
m_numWorldBSPs = 0;
GTH_SAFE_DELETE( m_MDLMng );
g_timeSystem->DeleteDeviceObjects();
break;
}
return S_OK;
}
HRESULT GTH::InvalidateDeviceObjects()
{
SAFE_RELEASE( m_pD3DXFont );
int i;
switch( g_cgv.state )
{
case CLIENT_START_PROCESS : case CLIENT_LOGIN_PROCESS : case CLIENT_CHARACTER_PROCESS :
g_ifMng->InvalidateDeviceObjects();
g_chatManager->InvalidateFont();
for( i = 0 ; i < m_numWorldBSPs ; i++ )
{
m_worldBSPs[ i ]->Release();
GTH_SAFE_DELETE( m_worldBSPs[ i ] );
}
memset ( m_worldBSPs, 0, sizeof(m_worldBSPs) );
m_numWorldBSPs = 0;
if( m_MDLMng )
m_MDLMng->Release();
GTH_SAFE_DELETE( m_MDLMng );
g_shaderMng.Release();
g_modelShaderMng->Release();
g_charShaderMng->Release();
g_charManager->ReleaseBuffers();
g_texMng.Release();
break;
case CLIENT_LOADING_PROCESS :
g_ifMng->InvalidateDeviceObjects();
g_chatManager->InvalidateFont();
g_texMng.Release();
break;
case CLIENT_GAME_PROCESS :
g_ifMng->InvalidateDeviceObjects();
g_chatManager->InvalidateFont();
for( i = 0 ; i < m_numWorldBSPs ; i++ )
{
m_worldBSPs[ i ]->Release();
GTH_SAFE_DELETE( m_worldBSPs[ i ] );
}
m_numWorldBSPs = 0;
if( m_MDLMng )
m_MDLMng->Release();
GTH_SAFE_DELETE( m_MDLMng );
g_shaderMng.Release();
g_modelShaderMng->Release();
g_charShaderMng->Release();
g_charManager->ReleaseBuffers();
g_timeSystem->InvalidateDeviceObjects();
g_texMng.Release();
break;
}
return S_OK;
}
HRESULT GTH::FinalCleanup()
{
g_timeSystem->FinalCleanup();
WriteSettings();
return S_OK;
}
void GTH::WritePackFileLog( char* str, ... )
{
#ifdef _DEBUG
FILE *fp;
char buf[4096];
va_list marker;
memset( buf, 0, sizeof( buf ) );
va_start( marker, str );
vsprintf( buf, str, marker);
fp = fopen( "gth.log", "at" );
fprintf( fp, "%s\n", buf );
fclose( fp );
#endif
}
LRESULT GTH::MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
HIMC m_hIMC = ImmGetContext(hWnd);
DWORD dwBufLen;
LPCANDIDATELIST m_CandList;
LPCANDIDATELIST lpCandList;
int CanNum;
switch( msg )
{
case WM_IME_NOTIFY:
switch( wParam )
{
case IMN_CHANGECANDIDATE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_CHANGECANDIDATE", wParam );
break;
case IMN_CLOSECANDIDATE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_CLOSECANDIDATE", wParam );
break;
case IMN_CLOSESTATUSWINDOW:
ShowLogInfo( "WM_IME_NOTIFY : IMN_CLOSESTATUSWINDOW", wParam );
break;
case IMN_GUIDELINE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_GUIDELINE", wParam );
break;
case IMN_OPENCANDIDATE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_OPENCANDIDATE", wParam );
break;
case IMN_SETCANDIDATEPOS:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETCANDIDATEPOS", wParam );
break;
case IMN_SETCOMPOSITIONFONT:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETCOMPOSITIONFONT", wParam );
break;
case IMN_SETCOMPOSITIONWINDOW:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETCOMPOSITIONWINDOW", wParam );
break;
case IMN_SETCONVERSIONMODE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETCONVERSIONMODE", wParam );
break;
case IMN_SETOPENSTATUS:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETOPENSTATUS", wParam );
break;
case IMN_SETSENTENCEMODE:
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETSENTENCEMODE", wParam );
break;
case IMN_SETSTATUSWINDOWPOS :
ShowLogInfo( "WM_IME_NOTIFY : IMN_SETSTATUSWINDOWPOS", wParam );
break;
}
case WM_GRAPHNOTIFY:
{
#ifndef _FMOD_SOUND
#endif
}
break;
}
if( g_cgv.enableChat && !g_ifMng->m_msgWin->State() )
{
switch( g_chatManager->GetString( hWnd, msg, wParam, lParam ) )
{
case CHAT_INPUT_RETURN_NONE :
return 0;
case CHAT_INPUT_RETURN_OK :
{
switch( g_cgv.state )
{
case CLIENT_GAME_PROCESS :
{
switch( g_chatManager->GetCurrentInputIndex() )
{
case INPUT_INDEX_DIALOGBOX :
if(TRUE == g_pApp->m_myCharacter->m_bWaitingRoom)
{
chatMessage tempstr;
strcpy(tempstr,g_chatManager->m_returnStr);
if(NULL != strchr(tempstr,' ')) *strchr(tempstr,' ')=NULL;
if(0 != strcmp(tempstr,g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,385))){
g_ifMng->AddSysMessage( g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,148), D3DCOLOR_ARGB(255, 55, 255, 55) );
g_ifMng->m_dlgWin->SetSendString();
break;
}
}
if(g_cgv.myCharacterInfo->m_dwLimite_ChatTime<=0.0f)
{
if(g_pApp->m_myCharacter->isTransform == 1 &&
g_pApp->m_myCharacter->transformEntityIdx == 237)
{
sprintf( g_chatManager->m_returnStr, g_LPACK.GetMassage(LPACK_TYPE_NORMAL2,399));
}
GTH_ChatCommand( g_chatManager->m_returnStr );
g_ifMng->m_dlgWin->SetScrollBarPositionMax();
}
break;
case INPUT_INDEX_BOOTH_NAME :
g_chatManager->ChangeInputMessage( INPUT_INDEX_BOOTH_INFO );
break;
case INPUT_INDEX_BOOTH_INFO :
g_chatManager->ChangeInputMessage( INPUT_INDEX_BOOTH_NAME );
break;
case INPUT_INDEX_MAIL_NAME :
g_chatManager->ChangeInputMessage( INPUT_INDEX_MAIL_TITLE );
break;
case INPUT_INDEX_MAIL_TITLE :
g_ifMng->m_mailEditWin->m_bVisibleCursor = true;
g_chatManager->ChangeInputMessage( INPUT_INDEX_MAIL_CONTENT );
break;
case INPUT_INDEX_MAIL_CONTENT :
break;
case INPUT_INDEX_GUILD_SCHEDULE :
{
strcpy( g_ifMng->m_guildWin->m_scheduleString, g_chatManager->m_returnStr );
memset( g_chatManager->m_returnStr, 0, sizeof( chatMessage ) );
g_chatManager->InitInputStr( INPUT_INDEX_GUILD_SCHEDULE );
g_ifMng->m_guildWin->m_scheduleBtn->SetButtonState( IF_BTN_TYPE_ENABLE );
GTH_SendMessage_Guild_Schedule_Request( g_ifMng->m_guildWin->m_scheduleString );
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
}
break;
case INPUT_INDEX_WORLDCHAT :
{
if(g_cgv.myCharacterInfo->m_dwLimite_ChatTime<=0.0f)
{
char msg[CHATSTRING];
strcpy( msg, g_chatManager->m_returnStr );
if( msg[0] != 0 )
GTH_SendMessage_WorldChatting( msg, g_ifMng->m_worldChatWin->GetType());
g_chatManager->InitInputStr( INPUT_INDEX_WORLDCHAT );
g_ifMng->m_worldChatWin->Enable( false );
}
memset( g_chatManager->m_returnStr, 0, sizeof( g_chatManager->m_returnStr ) );
g_chatManager->ChangeInputMessage( INPUT_INDEX_DIALOGBOX );
}
break;
case INPUT_INDEX_POST_NAME:
g_chatManager->ChangeInputMessage(INPUT_INDEX_POST_MESSAGE);
break;
case INPUT_INDEX_POST_TITLE:
g_ifMng->m_mailBoxWin->m_bVisibleCursor = true;
g_chatManager->ChangeInputMessage(INPUT_INDEX_POST_NAME);
break;
case INPUT_INDEX_POST_MESSAGE:
break;
case INPUT_INDEX_GIFT_CARD_ID:
g_chatManager->ChangeInputMessage(INPUT_INDEX_GIFT_CARD_ID);
break;
case INPUT_INDEX_GIFT_CARD_PASSWORD:
g_chatManager->ChangeInputMessage(INPUT_INDEX_GIFT_CARD_PASSWORD);
break;
default:
break;
}
}
break;
}
}
return 0;
case CHAT_INPUT_RETURN_TAB :
switch( g_cgv.state )
{
case CLIENT_LOGIN_PROCESS :
g_chatManager->m_curIdx ++;
g_chatManager->m_curIdx = g_chatManager->m_curIdx % 2;
break;
case CLIENT_GAME_PROCESS :
{
switch( g_chatManager->GetCurrentInputIndex() )
{
case INPUT_INDEX_BOOTH_NAME :
g_chatManager->ChangeInputMessage( INPUT_INDEX_BOOTH_INFO );
break;
case INPUT_INDEX_BOOTH_INFO :
g_chatManager->ChangeInputMessage( INPUT_INDEX_BOOTH_NAME );
break;
case INPUT_INDEX_MAIL_NAME :
g_chatManager->ChangeInputMessage( INPUT_INDEX_MAIL_TITLE );
break;
case INPUT_INDEX_MAIL_TITLE :
g_ifMng->m_mailEditWin->m_bVisibleCursor = true;
g_chatManager->ChangeInputMessage( INPUT_INDEX_MAIL_CONTENT );
break;
case INPUT_INDEX_MAIL_CONTENT :
break;
case INPUT_INDEX_POST_NAME:
g_chatManager->ChangeInputMessage(INPUT_INDEX_POST_MESSAGE);
break;
case INPUT_INDEX_POST_TITLE:
g_ifMng->m_mailBoxWin->m_bVisibleCursor = true;
g_chatManager->ChangeInputMessage(INPUT_INDEX_POST_NAME);
break;
case INPUT_INDEX_POST_MESSAGE:
break;
case INPUT_INDEX_GIFT_CARD_ID:
g_chatManager->ChangeInputMessage(INPUT_INDEX_GIFT_CARD_PASSWORD);
break;
case INPUT_INDEX_GIFT_CARD_PASSWORD:
g_chatManager->ChangeInputMessage(INPUT_INDEX_GIFT_CARD_ID);
break;
}
}
break;
}
return 0;
case CHAT_INPUT_RETURN_EXIT :
switch( g_cgv.state )
{
case CLIENT_GAME_PROCESS :
GTH_ChatCommand( "" );
break;
}
return 0;
}
}
if( g_input->Handle_messages( hWnd, msg, wParam, lParam ) )
return 0;
return CD3DApplication::MsgProc( hWnd, msg, wParam, lParam );
}
HRESULT GTH::RestoreDeviceObjects()
{
g_camera.m_projectParm.aspect = (float) m_d3dsdBackBuffer.Width / (float) m_d3dsdBackBuffer.Height;
D3DXMatrixPerspectiveFovLH( (D3DXMATRIX*)&g_camera.m_projMat , deg2rad( g_camera.m_projectParm.fov / g_camera.m_projectParm.aspect )
, g_camera.m_projectParm.aspect , g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_camera.SetupViewPort( 0 , 0 , m_d3dsdBackBuffer.Width , m_d3dsdBackBuffer.Height
, g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_cursor->SetupViewPort( 0 , 0 , m_d3dsdBackBuffer.Width , m_d3dsdBackBuffer.Height
, g_camera.m_projectParm.znear , g_camera.m_projectParm.zfar );
g_input->SetHWND( m_hWnd );
g_input->Resize( m_d3dpp.BackBufferWidth,m_d3dpp.BackBufferHeight );
RestoreApp();
return S_OK;
}
| C++ |
#if !defined(AFX_CTERRACTRL_H__3F2768FC_2BE7_4B48_961C_984FFC90C028__INCLUDED_)
#define AFX_CTERRACTRL_H__3F2768FC_2BE7_4B48_961C_984FFC90C028__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#include "..\global_def.h"
class CTerraCtrl
{
private:
BOOL m_bOK;
protected:
struct tagIdentify{
public:
enum{
MaxBytes_ID =20,
MaxBytes_Password=20,
};
struct tagTerra{
public:
enum{
maxbytes_tid=200,
};
public:
BOOL bActive;
char id[maxbytes_tid+1];
};
public:
char id[MaxBytes_ID+1];
char password[MaxBytes_Password+1];
struct tagTerra Terra;
};
struct tagIdentify m_Identify;
public:
BOOL isOK(void) const;
void CommandlineParam(const char* pCommandLine);
void GTH_SendMessage_RequestLogin( void );
void GTH_ProcessMessage_ReplyLogin_SetID(const char* pID);
BOOL isTerraIDUse(void) const;
public:
void GTH_ProcessMessage_ReplyLogin(void);
void Decoder(void);
inline void Decoder_Open_MessageBox(void);
inline void Decoder_NoticeMessage(void);
inline void Decoder_Remain_Minute_NoticeMessage(void);
public:
CTerraCtrl();
virtual ~CTerraCtrl();
};
#endif
| C++ |
#if !defined(AFX_LANGUAGE_H__FD108350_EBFF_4D60_8097_F8D0100DA872__INCLUDED_)
#define AFX_LANGUAGE_H__FD108350_EBFF_4D60_8097_F8D0100DA872__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif
#define LPACK_SEMICOLON 59
#define LPACK_COLON 58
#define LPACK_BACKSLASH 92
#define LPACK_LINEFEED 10
#define LPACK_RETURN 13
#define LPACK_QUOTATION 34
#define TEMPBUFFER_SIZE 4096
enum
{
LPACK_TYPE_NORMAL=0,
LPACK_TYPE_NPC,
LPACK_TYPE_QUESTINFO,
LPACK_TYPE_HELP,
LPACK_TYPE_ANSWER,
LPACK_TYPE_ETC,
LPACK_TYPE_ABUSE,
LPACK_TYPE_TIP,
LPACK_TYPE_TUTORIAL,
LPACK_TYPE_NORMAL2,
LPACK_TYPE_AUTOSCROLL,
LPACK_TYPE_ABUSE2,
LPACK_TYPE_SKILL,
LPACK_TYPE_TERRA,
LPACK_TYPE_CHARACTER_NAME,
LPACK_TYPE_ITEM,
LPACK_TYPE_COUNT,
};
#pragma warning (disable : 4786)
#include <vector>
#include <string>
#include <map>
using namespace std;
class CLPack
{
protected:
std::vector<std::string*> m_vLPackData;
typedef map<int , string*> CMap_LpackData;
CMap_LpackData m_strMapLPackData;
int m_LPackType;
CFileMng* m_pFileMng;
int m_MaxMessageCount;
public:
virtual bool LoadFile(char* filename);
int GetLpackType();
virtual char* GetMessage(int Idx, int etc1 = 0, int etc2 = 0);
int GetMessageCount();
inline char* Get(int Idx);
bool IfLineFeed(char *TokenBuffer);
public:
virtual void Init();
virtual void Destroy();
public:
static char* m_pUnknownMsg_Empty;
static char* m_pUnknownMsg_RangeOverflow_String;
static char* m_pUnknownMsg_RangeOverflow_Quest;
static char* m_pUnknownMsg_RangeOverflow_Etc;
static char* m_pUnknownMsg_RangeOverflow_Type;
public:
CLPack ();
CLPack (char *filename, CFileMng* pFileMng);
~CLPack();
};
inline char* CLPack::Get(int Idx)
{
CMap_LpackData::iterator iter;
iter=m_strMapLPackData.find(Idx);
if(iter==m_strMapLPackData.end()) return m_pUnknownMsg_Empty;
string* pstring = (string *) iter->second;
if ((char*)pstring ->c_str() == NULL) return m_pUnknownMsg_Empty;
return (char*)pstring->c_str();
}
inline char* CLPack::GetMessage(int Idx, int etc1, int etc2)
{
if ( Idx >= m_vLPackData.size() || Idx <= -1)
return m_pUnknownMsg_RangeOverflow_String;
std::string* pstring = (m_vLPackData[Idx]);
if ((char*)pstring ->c_str() == NULL) return m_pUnknownMsg_Empty;
return (char*)pstring ->c_str();
}
class CLPack_Quest : public CLPack
{
public:
enum MESSAGETYPE
{
TYPE_QUESTNAME,
TYPE_QUESTSTEP
};
struct sStepMessage
{
int step;
void* Message;
};
struct sQuestMessage
{
int QuestNum;
vector <sStepMessage*> v_StepMessage;
};
int m_LastQuestMessageIdx;
private:
vector<sQuestMessage*> m_vQuestMessage;
public:
bool LoadFile(char* filename);
char* GetMessage(int Idx, int etc1, int etc2);
public:
void Init();
void Destroy();
public:
CLPack_Quest(char *filename, CFileMng* pFileMng)
{
Init();
m_pFileMng = pFileMng;
LoadFile(filename);
}
CLPack_Quest(){};
~CLPack_Quest(){};
};
inline char* CLPack_Quest::GetMessage(int messageType, int QuestNum , int Step)
{
if ( messageType == TYPE_QUESTNAME)
{
return CLPack::GetMessage(QuestNum);
}
else
{
std::string* pstring = NULL;
if (QuestNum >= m_vQuestMessage.size()) return m_pUnknownMsg_RangeOverflow_Quest;
for (int i = 0; i < m_vQuestMessage[QuestNum]->v_StepMessage.size(); i ++)
{
if (m_vQuestMessage[QuestNum]->v_StepMessage[i]->step == Step)
{
pstring = (std::string*)(m_vQuestMessage[QuestNum]->v_StepMessage[i]->Message);
return (char*)pstring->c_str();
}
else if (m_vQuestMessage[QuestNum]->v_StepMessage[i]->step < Step)
{
m_LastQuestMessageIdx = i;
}
}
pstring = (std::string*)(m_vQuestMessage[QuestNum]->v_StepMessage[m_LastQuestMessageIdx]->Message);
return (char*)pstring->c_str();
}
return NULL;
}
class CLPack_Etc : public CLPack
{
public:
enum MESSAGETYPE
{
LPACK_ETCTYPE_GEN_ATTRIBUTE,
LPACK_ETCTYPE_PC_JOB,
LPACK_ETCTYPE_WEAPON_TYPE,
LPACK_ETCTYPE_RARITY,
LPACK_ETCTYPE_PATCH,
LPACK_ETCTYPE_GOLRYUN_BATTLE,
TYPE_COUNT
};
private:
std::vector<std::vector< void* >* > m_vpMessage;
int m_NowvpIdx;
public:
bool LoadFile(char* filename);
char* GetMessage(int Idx, int etc1, int etc2 = 0);
public:
std::vector<void*>* GetVector(int idx)
{
return m_vpMessage[idx];
}
public:
void Init();
void Destroy();
public:
CLPack_Etc(char *filename, CFileMng* pFileMng)
{
Init();
m_pFileMng = pFileMng;
LoadFile(filename);
}
CLPack_Etc(){};
~CLPack_Etc(){};
};
inline char* CLPack_Etc::GetMessage(int Idx, int etc1, int etc2)
{
if (Idx >= m_vpMessage.size()) return m_pUnknownMsg_RangeOverflow_Etc;
if ( etc1 >= GetVector(Idx)->size() ) return m_pUnknownMsg_RangeOverflow_String;
std::string* pString = (std::string*)(*GetVector(Idx))[etc1];
return (char*)pString->c_str();
}
#endif
| C++ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.