void worker(void)
{
EMQ::Client client(ADDR, EMQ_DEFAULT_PORT);
const std::string &test_message = "Hello EagleMQ";
EMQ::Message message((void*)test_message.c_str(), test_message.length() + 1, true);
bool status;
int i;
if (client.connected())
{
std::cout << YELLOW("[Success]") << " [Worker] Connected to "
<< ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
status = client.auth("eagle", "eagle");
CHECK_STATUS("[Worker] Auth", status);
for (i = 0; i < MESSAGES / 2; i++)
{
status = client.channel.publish(".channel-test", "world.russia.moscow", message);
CHECK_STATUS("[Worker] Channel publish", status);
status = client.channel.publish(".channel-test", "world.belarus.minsk", message);
CHECK_STATUS("[Worker] Channel publish", status);
sleep(1);
}
client.disconnect();
}
else
{
std::cout << RED("[Error]") << " Error connect to " << ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
}
}
static inline
int IsKnownOrIgnoredToken(GLArbToken* ArbHash, GLToken* Token, GLSettings* Settings)
{
int Found = 0;
GLArbToken* ArbToken = GetToken(ArbHash, Token->Hash);
if (ArbToken)
{
Found = 1;
}
else
{
for (int IgnoredIndex = 0; IgnoredIndex < Settings->IgnoreCount; ++IgnoredIndex)
{
if (Equal(Token->Value, Settings->Ignores[IgnoredIndex]))
{
Found = 1;
break;
}
}
if (!Found)
{
fprintf(stderr, YELLOW("WARNING") ": Token not found in header: %" PRI_STR "\n",
Token->Value.Length, Token->Value.Chars);
}
}
return Found;
}
int queue_message_callback(emq_client *_client, int, const char *name, const char *, const char *, emq_msg *msg)
{
EMQ::Client client(_client);
EMQ::Message message(msg);
printf(YELLOW("[Success]") " [Event] Message \'%s\' in queue %s\n", (char*)emq_msg_data(msg), name);
if (++message_counter >= MESSAGES)
{
client.set_noack_mode(true);
std::cout << YELLOW("[Success]") << " [Event] Queue unsubscribe" << std::endl;
client.queue.unsubscribe(".queue-test");
client.set_noack_mode(false);
return 1;
}
return 0;
}
int channel_message_callback(emq_client *_client, int /*type*/, const char *name,
const char *topic, const char *pattern, emq_msg *msg)
{
EMQ::Client client(_client);
EMQ::Message message(msg);
printf(YELLOW("[Success]") " [Event] Message \'%s\' (channel: %s, pattern: %s, topic: %s) \n",
(char*)message.data(), name, pattern, topic);
if (++message_counter >= MESSAGES)
{
client.set_noack_mode(true);
std::cout << YELLOW("[Success]") << " [Event] Channel punsubscribe" << std::endl;
client.channel.punsubscribe(".channel-test", "world.belarus.*");
client.set_noack_mode(false);
return 1;
}
return 0;
}
int main(void)
{
EMQ::Client client(ADDR, EMQ_DEFAULT_PORT);
bool status;
std::cout << MAGENTA("This is a simple example of using libemq++") << std::endl;
if (!EMQ::compatible())
{
std::cout << RED("[Warning]") << " Used incompatible version libemq" << std::endl;
}
if (client.connected())
{
std::cout << YELLOW("[Success]") << " Connected to " << ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
status = client.auth("eagle", "eagle");
CHECK_STATUS("Auth", status);
status = client.queue.create(".queue-test", 10, 100, EMQ_QUEUE_FORCE_PUSH | EMQ_QUEUE_AUTODELETE);
CHECK_STATUS("Queue create", status);
status = client.queue.declare(".queue-test");
CHECK_STATUS("Queue declare", status);
status = client.queue.subscribe(".queue-test", EMQ_QUEUE_SUBSCRIBE_MSG, queue_message_callback);
CHECK_STATUS("Queue subscribe", status);
std::thread thread = std::thread(worker);
status = client.process();
CHECK_STATUS("Channel process", status);
thread.join();
client.disconnect();
}
else
{
std::cout << RED("[Error]") << " Error connect to " << ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
}
return 0;
}
int main(void)
{
EMQ::Client client(ADDR, EMQ_DEFAULT_PORT);
bool status;
std::cout << MAGENTA("This is a simple example of using libemq++") << std::endl;
if (!EMQ::compatible())
{
std::cout << RED("[Warning]") << " Used incompatible version libemq" << std::endl;
}
if (client.connected())
{
std::cout << YELLOW("[Success]") << " Connected to " << ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
status = client.auth("eagle", "eagle");
CHECK_STATUS("Auth", status);
status = client.channel.create(".channel-test", EMQ_CHANNEL_AUTODELETE | EMQ_CHANNEL_ROUND_ROBIN);
CHECK_STATUS("Channel create", status);
status = client.channel.psubscribe(".channel-test", "world.belarus.*", channel_message_callback);
CHECK_STATUS("Channel psubscribe", status);
std::thread thread1 = std::thread(worker);
std::thread thread2 = std::thread(worker);
status = client.process();
CHECK_STATUS("Channel process", status);
thread1.join();
thread2.join();
client.disconnect();
}
else
{
std::cout << RED("[Error]") << " Error connect to " << ADDR << ":" << EMQ_DEFAULT_PORT << std::endl;
}
return 0;
}
void PrintResult()
{
FILE *ResultFileDescriptor = fopen("RESULT", "r");
if (ResultFileDescriptor == NULL)
{
printf("JF\n");
return;
}
char Temp[256];
int BriefResult;
int TimeUsed;
int MemoryUsed;
fscanf(ResultFileDescriptor, "%s%d%s%d%s%d", Temp, &BriefResult, Temp, &TimeUsed, Temp, &MemoryUsed);
fclose(ResultFileDescriptor);
switch (BriefResult)
{
case TR_AC:
printf(GREEN(" AC"));
break;
case TR_WA:
printf(RED(" WA"));
break;
case TR_RE:
printf(YELLOW(" RE"));
break;
case TR_TLE:
printf(RED("TLE"));
break;
case TR_MLE:
printf(RED("MLE"));
break;
default:
printf("---");
}
if (BriefResult == TR_TLE)
{
printf(" %8dKB\n", MemoryUsed);
}
else
{
printf("%6dms %8dKB\n", TimeUsed, MemoryUsed);
}
}
static void print_stack(void)
{
static const char *const nts[] = {
"Unit",
"Stmt",
"Assn",
"Prnt",
"Ctrl",
"Cond",
"Elif",
"Else",
"Dowh",
"Whil",
"Atom",
"Expr",
"Pexp",
"Bexp",
"Uexp",
"Texp",
"Aexp",
};
assert(sizeof(nts) / sizeof(*nts) == NT_COUNT);
for (size_t i = 0; i < stack.size; ++i) {
const struct node *const node = &stack.nodes[i];
if (node->nchildren) {
printf(YELLOW("%s "), nts[node->nt]);
} else if (node->token->tk == TK_FBEG) {
printf(GREEN("^ "));
} else if (node->token->tk == TK_FEND) {
printf(GREEN("$ "));
} else {
const ptrdiff_t len = node->token->end - node->token->beg;
printf(GREEN("%.*s "), (int) len, node->token->beg);
}
}
puts("");
}
void Verbose::generateReplacementString(const CombinatorPtr& term1, const CombinatorPtr& term2)
{
if (!isVerbose())
return;
QString from = term1->toString();
QString to = term2->toString();
if (from.isEmpty() || to.isEmpty())
return;
*m_stream << " "
<< prefix()
<< YELLOW()
<< from
<< "->"
<< to
<< RESET()
<< postfix()
<< "\n";
print();
}
void am_warn(const char *pretty_func, const char *_file,
int line, const char *_format, ...)
{
init();
if (AM_UNLIKELY(AM_LOG_LEVEL_WARN <= logLevel)) {
char text[2*1024] = {0};
char module[256] = {0};
char func[256] = {0};
char file[256] = {0};
char format[2*1024] = {0};
va_list vlist;
function_name(func, sizeof(func), pretty_func);
class_name(module, sizeof(module), pretty_func);
file_name(file, sizeof(file), _file);
snprintf(format, sizeof(format), "%s", _format);
if (format[strlen(format) - 1] == '\n') {
//Eat trailing \n, \n will be added automatically!
format[strlen(format) - 1] = '\0';
}
if (logTarget == AM_LOG_TARGET_SYSLOG) {
sprintf(text, "[%6s][%s:%d: %s]: %s",
"WARN", file, line, func, format);
} else if (logTarget == AM_LOG_TARGET_FILE) {
sprintf(text, "[%20s][%6s][%s:%d: %s]: %s",
module, "WARN", file, line, func, format);
} else {
sprintf(text, "["B_GREEN("%20s")"]["B_YELLOW("%6s")"]"\
CYAN("[%s:%d: %s]: ")YELLOW("%s"),
module, "WARN", file, line, func, format);
}
va_start(vlist, _format);
am_level_logv(module, AM_LOG_LEVEL_WARN, text, vlist);
va_end(vlist);
}
}
//------------------------------------------------------------------------------
// ゲームの初期化
//------------------------------------------------------------------------------
// 引数
// なし
// 戻り値
// なし
//------------------------------------------------------------------------------
void CGame::Init(void)
{
gamePhase = PHASE_3;
gamePhaseCnt = 0;
gameEndCount = 0;
CSoundAL::Play(CSoundAL::BGM_GAME);
//地形生成
Ground = nullptr;
Ground = CMeshGround::Create(VECTOR3(0.0f,0.0f,0.0f),VECTOR2(FIELD_PANEL_SIZE,FIELD_PANEL_SIZE),VECTOR2(0,0),1.5f);
Ground->SetTex(CTexture::Texture(TEX_FIELD));
// 空生成
Sky = nullptr;
Sky = CMeshSphere::Create(VECTOR3(0.0f,0.0f,0.0f),VECTOR2(16.0f,8.0f),RADIUS_SKY);
Sky->SetTex(CTexture::Texture(TEX_SKY));
// 境界線生成
CylinderArea = nullptr;
CylinderArea = CBattleAreaCylinder::Create(VECTOR3(0.0f,0.0f,0.0f),HEIGHT_WALL,VECTOR2(64.0f,1.0f),RADIUS_AREA_BATTLE,VECTOR2(1,-0.5f));
CylinderArea->SetTex(CTexture::Texture(TEX_WALL));
CylinderArea->SetAlpha(0.5f);
Player = new CPlayer*[PLAYER_MAX];
// プレイヤー生成
for (int i = 0; i < PLAYER_MAX; i++)
{
if (i % 2 == 1)
Player[i] = CPlayer::Create(CModel::RINCHAN,PLAYER_POSITION_LIST[i],i);
else
Player[i] = CPlayer::Create(CModel::YOUJO,PLAYER_POSITION_LIST[i],i);
Player[i]->SetTex(CTexture::Texture(TEX_YOUJO_RED + i));
Player[i]->SetDestRot(PLAYER_ROTATION_LIST[i]);
Player[i]->SetRot(PLAYER_ROTATION_LIST[i]);
Player[i]->setBarrelTex(TEX_YOUJO_RED + i);
if (i == CManager::netData.charNum)
{
Player[i]->SetPlayerFlag(true);
Player[i]->CreateBallistic();
}
}
//プレイヤーカメラ生成
CPlayerCamera::Create(Player[CManager::netData.charNum],35.0f);
// 【テスト】各プレイヤーの色をセット
for(int i = 0; i < PLAYER_MAX; i++)
{
switch(i)
{
// 赤
case 0:
Player[i]->SetPlayerColor(RED(0.5f));
break;
// 青
case 1:
Player[i]->SetPlayerColor(BLUE(0.5f));
break;
// 水
case 2:
Player[i]->SetPlayerColor(CYAN(0.5f));
break;
// 橙
case 3:
Player[i]->SetPlayerColor(COLOR(1.0f, 0.7f, 0.0f, 0.5f));
break;
// 白
case 4:
Player[i]->SetPlayerColor(WHITE(0.5f));
break;
// P
case 5:
Player[i]->SetPlayerColor(YELLOW(0.5f));
break;
default:
break;
}
}
// プレイヤーの入力を止める
for (int i = 0; i < PLAYER_MAX; i++){
Player[i]->SetInputFlag(false);
}
// UI初期化
UI = new CUI;
UI->Init();
UI->setMyID(CManager::netData.charNum);
UI->SetPlayer(Player);
UI->MiniMap()->SetFieldSize(VECTOR3(RADIUS_AREA_BATTLE*2.25f,0,RADIUS_AREA_BATTLE*2.25f));
// 岩の生成
ppRock_ = new CModel*[MAX_ROCK];
for (int cntRock = 0; cntRock < MAX_ROCK; ++cntRock)
{
ppRock_[cntRock] = CModel::Create(CModel::ROCK,ROCK_POSITION_LIST[cntRock]);
ppRock_[cntRock]->SetRot(ROCK_ROTATION_LIST[cntRock]);
ppRock_[cntRock]->SetScl(1,1,1);
ppRock_[cntRock]->SetTex(CTexture::Texture(TEX_ROCK));
PushBackObjectByField(ppRock_[cntRock], 10.0f);
}
// 影生成
Shadow = new CShadow*[2 * PLAYER_MAX];
for (int cntShadow = 0; cntShadow < 2 * PLAYER_MAX; ++cntShadow)
{
Shadow[cntShadow] = nullptr;
Shadow[cntShadow] = CShadow::Create(VECTOR3(0.0f, 0.0f, 0.0f), VECTOR2(1.0f, 1.0f));
if (cntShadow < PLAYER_MAX)
{
Shadow[cntShadow]->SetScl(30, 30, 30);
}
else
{
Shadow[cntShadow]->SetScl(20, 20, 20);
}
Shadow[cntShadow]->SetTex(CTexture::Texture(TEX_SHADOW));
}
CManager::gameStartFlag = true;
CManager::sendGameStart();
}
/*
*time: level: process[pid]: [tid] tag: message
* [verbose ]
*/
static int _log_print(int lvl, const char *tag,
const char *file, int line,
const char *func, const char *msg)
{
int ret = 0, i = 0;
struct iovec vec[LOG_IOVEC_MAX];
char s_time[LOG_TIME_SIZE];
char s_lvl[LOG_LEVEL_SIZE];
char s_tag[LOG_TAG_SIZE];
char s_pname[LOG_PNAME_SIZE];
char s_pid[LOG_PNAME_SIZE];
char s_tid[LOG_PNAME_SIZE];
char s_file[LOG_TEXT_SIZE];
char s_msg[LOG_BUF_SIZE];
pthread_mutex_lock(&_log_mutex);
log_get_time(s_time, sizeof(s_time), 0);
if (_log_fp == stderr || _log_fd == STDERR_FILENO) {
switch(lvl) {
case LOG_EMERG:
case LOG_ALERT:
case LOG_CRIT:
case LOG_ERR:
snprintf(s_lvl, sizeof(s_lvl),
B_RED("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), RED("%s"), msg);
break;
case LOG_WARNING:
snprintf(s_lvl, sizeof(s_lvl),
B_YELLOW("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), YELLOW("%s"), msg);
break;
case LOG_INFO:
snprintf(s_lvl, sizeof(s_lvl),
B_GREEN("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), GREEN("%s"), msg);
break;
case LOG_DEBUG:
snprintf(s_lvl, sizeof(s_lvl),
B_WHITE("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), WHITE("%s"), msg);
break;
default:
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
break;
}
} else {
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
snprintf(s_pname, sizeof(s_pname), "[%s ", _proc_name);
snprintf(s_pid, sizeof(s_pid), "pid:%d ", getpid());
snprintf(s_tid, sizeof(s_tid), "tid:%d]", _gettid());
snprintf(s_tag, sizeof(s_tag), "[%s]", tag);
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
i = -1;
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TIMESTAMP_BIT)) {
vec[++i].iov_base = (void *)s_time;
vec[i].iov_len = strlen(s_time);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
vec[++i].iov_base = (void *)s_pname;
vec[i].iov_len = strlen(s_pname);
vec[++i].iov_base = (void *)s_pid;
vec[i].iov_len = strlen(s_pid);
vec[++i].iov_base = (void *)s_tid;
vec[i].iov_len = strlen(s_tid);
}
vec[++i].iov_base = (void *)s_lvl;
vec[i].iov_len = strlen(s_lvl);
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TAG_BIT)) {
vec[++i].iov_base = (void *)s_tag;
vec[i].iov_len = strlen(s_tag);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
vec[++i].iov_base = (void *)s_file;
vec[i].iov_len = strlen(s_file);
}
vec[++i].iov_base = (void *)s_msg;
vec[i].iov_len = strlen(s_msg);
if (UNLIKELY(!_log_syslog)) {
ret = _log_handle->write(vec, i+1);
}
pthread_mutex_unlock(&_log_mutex);
return ret;
}
