int bct_on_tile(t_server *server, t_client *graphic)
{
char *parameters[2];
int pos[2];
char *answ;
char buf[4096];
if (!server || !server->params || !graphic
|| !(parameters[0] = strtok(server->params, " \t"))
|| !(parameters[1] = strtok(NULL, " \t")))
return (sbp(graphic));
pos[0] = atoi(parameters[1]);
pos[1] = atoi(parameters[0]);
if (pos[0] >= 0 && pos[0] < server->data.world_y
&& pos[1] >= 0 && pos[1] < server->data.world_x)
{
if ((answ = bct(server->data.map, pos[0], pos[1])) == NULL)
return (-1);
if (memset(buf, 0, 4096) == NULL || snprintf(buf, 4096, MSG, answ) == -1)
return (fprintf(stderr, ERR_PRINTF), -1);
free(answ);
if (store_answer_c(graphic, strdup(buf), 0) == -1)
return (fprintf(stderr, ERR_BUFFER), -1);
return (0);
}
return (sbp(graphic));
}
GameVars::GameVars() : mouse(new Mouse) {
std::string path("../data/images/tiles/");
std::string soundpath("../data/sounds/");
std::string logotitlepath("../data/images/");
for(int i = 0; i < NUMTILES; i++) {
std::shared_ptr<sf::Image> img(new sf::Image);
if(!img->LoadFromFile(path + PadItoA(3, i) + ".png")) {
exit(EXIT_FAILURE);
}
tileImages.push_back(img);
std::shared_ptr<sf::Sprite> spr(new sf::Sprite(*tileImages[i]));
//spr->SetImage(*tileImages[i]);
tileSprites.push_back(spr);
}
for(int i = 0; i < NUMSOUNDS; i++) {
std::shared_ptr<sf::SoundBuffer> sbp(new sf::SoundBuffer);
sbp->LoadFromFile(soundpath + soundFilenames[i] + ".wav");
SoundBuffers.push_back(sbp);
std::shared_ptr<sf::Sound> sp(new sf::Sound(*sbp));
Sounds.push_back(sp);
}
// load title and logo
titleImage = std::shared_ptr<sf::Image>(new sf::Image);
titleImage->LoadFromFile(logotitlepath + "title.png");
titleSprite = std::shared_ptr<sf::Sprite>(new sf::Sprite(*titleImage));
logoImage = std::shared_ptr<sf::Image>(new sf::Image);
logoImage->LoadFromFile(logotitlepath + "logo.png");
logoSprite = std::shared_ptr<sf::Sprite>(new sf::Sprite(*logoImage));
}
int plv(char **av, t_client *cl, t_kernel *kernel)
{
int nb_player;
t_player *tempory_player;
char buff[BUFFER_SIZE];
if (av_length(av) != 2)
return (sbp(cl->fd));
nb_player = atoi(av[1]);
if (!(tempory_player = get_player_by_id(nb_player, kernel->game.players)))
return (sbp(cl->fd));
sprintf(buff, "plv %d %d\n", nb_player, tempory_player->level);
if (write_socket(cl->fd, buff) <= 0)
return (1);
return (0);
}
void QtOpenCVZedDemo::doStereoBP_OCL( cv::Mat left, cv::Mat right )
{
cv::ocl::StereoBeliefPropagation sbp;
int disp, iters, levels ;
sbp.estimateRecommendedParams( left.cols, left.rows, disp, iters, levels );
sbp.levels = levels;
sbp.iters = iters;
sbp.ndisp = disp;
if( left.channels() > 1 )
cv::cvtColor( left, left, CV_BGR2GRAY );
if( right.channels() > 1 )
cv::cvtColor( right, right, CV_BGR2GRAY );
cv::ocl::oclMat ocl_left;
cv::ocl::oclMat ocl_right;
cv::ocl::oclMat ocl_disp;
ocl_left.upload( left );
ocl_right.upload( right );
sbp( ocl_left, ocl_right, ocl_disp );
ocl_disp.download( mDisparity );
normalize(mDisparity, mDisparity, 0, 255, CV_MINMAX, CV_8U);
}
void sgt_set(t_env *e, int fd, char **arg)
{
char *str;
if (arg[1])
{
if (atof(arg[1]) > 0)
e->parser->delay = atof(arg[1]);
else
sbp(e, fd, arg);
asprintf(&str, "sgt %d\n", e->parser->delay);
write_on_client(str, fd);
xfree(str);
}
else
sbp(e, fd, arg);
}
void fptr_ppo(t_env *env, t_action *action)
{
int id;
char *err;
t_client *client;
err = NULL;
if (action->input[1] == NULL)
sbp(env);
else
{
id = strtol(action->input[1], &err, 10);
if (err[0] != '\0' || (client = find_by_id(env, id)) == NULL)
sbp(env);
else
ppo(env, client);
}
delete_action(action);
}
void sst(t_env *e, int fd, char **req, int tmp)
{
int t;
(void)tmp;
if (req[1] == NULL)
{
printf("Client #%d (GFX): Invalid request (too few arguments)\n", fd);
sbp(e, fd);
return ;
}
t = ft_atoi(req[1]);
if (t < 1 || t > MAX_T)
{
printf("Client #%d (GFX): Invalid request (1 <= t <= %d\n", fd, MAX_T);
sbp(e, fd);
return ;
}
e->opt.t = t;
notify_all_gfx_sgt(e);
}
int plv(t_server *server, t_client *graphic)
{
char *parameter;
int id;
t_player *player;
char buffer[40];
if (!server || !graphic || !server->params
|| !(parameter = strtok(server->params, " \t")))
return (sbp(graphic));
id = atoi(parameter);
if ((player = get_player_by_id(server, id)) == NULL)
return (sbp(graphic));
if (memset(buffer, 0, 40) == NULL
|| snprintf(buffer, 40, PLV,
player->id, player->level) == -1)
return (fprintf(stderr, ERR_MEMSET), -1);
if (store_answer_c(graphic, strdup(buffer), 0) == -1)
{
fprintf(stderr, ERR_PRINTF);
return (-1);
}
return (0);
}
void fptr_bct(t_env *env, t_action *action)
{
int x;
int y;
char *err1;
char *err2;
err1 = NULL;
err2 = NULL;
if (action->input == NULL || action->input[0] == NULL
|| action->input[1] == NULL || action->input[2] == NULL)
sbp(env);
else
{
x = strtol(action->input[1], &err1, 10);
y = strtol(action->input[2], &err2, 10);
if (x < (int)env->map.height && y < (int)env->map.width
&& err1[0] == '\0' && err2[0] == '\0')
bct(env, y, x);
else
sbp(env);
}
delete_action(action);
}
int bct(t_srv *srv, void *ptr, char *cmd1, char *cmd2)
{
t_graphic *g;
int tab[7];
int x_asked;
int y_asked;
t_object *tmp;
g = (t_graphic *)ptr;
if (!cmd1 || !cmd2)
return (sbp(g->graphic));
if ((x_asked = atoi(cmd1)) >= (int)srv->args.map_x)
return (SUCCESS);
if ((y_asked = atoi(cmd2)) >= (int)srv->args.map_y)
return (SUCCESS);
tmp = srv->begin[x_asked + (y_asked * srv->args.map_x)];
memset(tab, 0, sizeof(int) * 7);
while (tmp)
{
tab[tmp->type]++;
tmp = tmp->next;
}
return (bct_write_result(g, tab, x_asked, y_asked));
}
void
asrv::dispatch (ref<xhinfo> xi, const char *msg, ssize_t len,
const sockaddr *src)
{
if (!msg || len < 8 || getint (msg + 4) != CALL) {
seteof (xi, src, len < 0);
return;
}
xdrmem x (msg, len, XDR_DECODE);
auto_ptr<svccb> sbp (New svccb);
rpc_msg *m = &sbp->msg;
if (!xdr_callmsg (x.xdrp (), m)) {
trace (1) << "asrv::dispatch: xdr_callmsg failed\n";
seteof (xi, src);
return;
}
if (m->rm_call.cb_rpcvers != RPC_MSG_VERSION) {
trace (1) << "asrv::dispatch: bad RPC message version\n";
asrv_rpc_mismatch (xi, src, m->rm_xid);
return;
}
asrv *s = xi->stab[progvers (sbp->prog (), sbp->vers ())];
if (!s || !s->cb) {
if (asrvtrace >= 1) {
if (s)
warn ("asrv::dispatch: no callback for %s (proc = %u)\n",
s->rpcprog->name, sbp->proc ());
else
warn ("asrv::dispatch: invalid prog/vers %u/%u (proc = %u)\n",
(u_int) sbp->prog (), (u_int) sbp->vers (),
(u_int) sbp->proc ());
}
asrv_accepterr (xi, src, PROG_UNAVAIL, m);
return;
}
if (s->recv_hook)
s->recv_hook ();
sbp->init (s, src);
if (sbp->proc () >= s->nproc) {
if (asrvtrace >= 1)
warn ("asrv::dispatch: invalid procno %s:%u\n",
s->rpcprog->name, (u_int) sbp->proc ());
asrv_accepterr (xi, src, PROC_UNAVAIL, m);
return;
}
if (s->isreplay (sbp.get ())) {
trace (4, "replay %s:%s x=%x",
s->rpcprog->name, s->tbl[m->rm_call.cb_proc].name,
xidswap (m->rm_xid)) << sock2str (src) << "\n";
return;
}
const rpcgen_table *rtp = &s->tbl[sbp->proc ()];
sbp->arg = s->tbl[sbp->proc ()].alloc_arg ();
if (!rtp->xdr_arg (x.xdrp (), sbp->arg)) {
if (asrvtrace >= 1)
warn ("asrv::dispatch: bad message %s:%s x=%x", s->rpcprog->name,
rtp->name, xidswap (m->rm_xid))
<< sock2str (src) << "\n";
asrv_accepterr (xi, src, GARBAGE_ARGS, m);
s->inc_svccb_count ();
s->sendreply (sbp.release (), NULL, true);
return;
}
if (asrvtrace >= 2) {
if (const authunix_parms *aup = sbp->getaup ())
trace (2, "serve %s:%s x=%x u=%u g=%u",
s->rpcprog->name, rtp->name, xidswap (m->rm_xid),
aup->aup_uid, aup->aup_gid)
<< sock2str (src) << "\n";
else if (u_int32_t i = sbp->getaui ())
trace (2, "serve %s:%s x=%x i=%u",
s->rpcprog->name, rtp->name, xidswap (m->rm_xid), i)
<< sock2str (src) << "\n";
else
trace (2, "serve %s:%s x=%x",
s->rpcprog->name, rtp->name, xidswap (m->rm_xid))
<< sock2str (src) << "\n";
}
if (asrvtrace >= 5 && rtp->print_arg)
rtp->print_arg (sbp->arg, NULL, asrvtrace - 4, "ARGS", "");
s->inc_svccb_count ();
(*s->cb) (sbp.release ());
}
void MainWindow::queueSimulations(const std::vector<openstudio::path> &t_files)
{
if (t_files.empty())
{
QMessageBox::information(this, "No Files Selected", "Please select files for simulation");
return;
}
openstudio::path epw;
QString jobtype;
bool wantsepw = false;
if (ui.rbIDF->isChecked())
{
epw = openstudio::toPath(ui.comboBoxEPWFiles->currentText());
wantsepw = true;
jobtype = "IDF";
} else if (ui.rbOSM->isChecked()) {
wantsepw = false;
jobtype = "OSM";
} else if (ui.rbXML->isChecked()) {
epw = openstudio::toPath(ui.comboBoxEPWFiles->currentText());
wantsepw = true;
jobtype = "XML";
} else {
assert("!Unknown job type");
}
if (wantsepw)
{
if (epw.empty())
{
if (QMessageBox::warning(this, "No EPW Selected",
"No EPW is selected, the application will try to find a matching epw from the default epw directory",
QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
{
return;
}
epw = m_runmanager.getConfigOptions().getDefaultEPWLocation();
}
}
bool runjobs = true;
if (t_files.size() > 1)
{
QString text = "Add " + QString::number(t_files.size());
text += " " + jobtype;
text += " jobs to queue?";
if (wantsepw)
{
text += "\n\nEPW: ";
if (epw.empty())
{
text += "None";
} else {
text += toQString(epw.external_file_string());
}
}
text += "\nWorkflow: " + ui.cbWorkflow->currentText();
if (QMessageBox::question(this, "Add Jobs To Queue?", text, QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok)
{
runjobs = true;
} else {
runjobs = false;
}
}
if (runjobs)
{
setEnabled(false);
StatusBarProgress sbp("Adding jobs to queue", statusBar());
sbp.update(0, t_files.size()-1, 0);
int place = 0;
for (std::vector<openstudio::path>::const_iterator itr = t_files.begin();
itr != t_files.end();
++itr)
{
queueSimulation(*itr, epw);
++place;
sbp.update(place);
}
// ui.listFiles->clearSelection();
// m_fss.selectNone();
setEnabled(true);
}
}
/*---------------------------------------------------------------------*//**
フレーム処理
**//*---------------------------------------------------------------------*/
void MagicTypingMode::exec(ExecRes* res, const ExecCtx* ec)
{
GameModeBase::exec(res, ec);
switch(_smode)
{
case SMODE_TYPING:
{
SourceEditWindow* wndSrcedt = Game::getGame()->getGui()->getSourceEditWindow();
ASSERT(wndSrcedt != 0L);
if(wndSrcedt->isDone()) // 完了検知
{
// 入力完了ならばマ法を放つ
if(wndSrcedt->isInputDone())
{
if(Game::getGame()->getMyParty()->pcUnit(MyParty::PC_MY) != 0L)
{
// 自キャラを得る
Spirit* sprt = Game::getGame()->getMyParty()->pcUnit(MyParty::PC_MY)->spirit();
ASSERT(sprt != 0L);
// ソースコードを得る
VcString code;
wndSrcedt->takeSourceText(&code);
// ソウマ実行
if( (code.getLength() > 0) &&
(_srckind != SourceDef::SRCKIND_NULL) )
{
Spirit::SoumaBehaviorParam sbp(
&code, // ソースコードを設定する
_srckind, // 最終種別を適用
false ); // 現時点では不明
sprt->startBehavior(Spirit::BEHV_SOUMA, &sbp);
}
// ソースエディトウインドウのソース文字列から不要なスペースや改行を削除する
wndSrcedt->trimSourceText();
// フォーカスカーサーの操作をしばらく禁止する
FocusCursor* fccsr = Game::getGame()->getGui()->getFocusCursor();
ASSERT(fccsr != 0L);
fccsr->setPreventTapCounter(30.0f); // 30 フレーム待て
}
// 以前のモードへ戻る
changePrevMode();
}
// リスト入力による完了ならばマ法リストウインドウを開く
else if(wndSrcedt->isListClickDone())
{
// マ法リストウインドウを開く
SourceListWindow* wndSourcelist = Game::getGame()->getGui()->getMagicListWindow();
ASSERT(wndSourcelist != 0L);
wndSourcelist->setCase(SourceListWindow::SLWCASE_SELECT);
wndSourcelist->showWindow(true);
_smode = SMODE_SELLIST;
}
// キャンセル
else
{
// 以前のモードへ戻る
changePrevMode();
}
// マ法入力ウインドウを閉じる
SourceEditWindow* wndSrcedt = Game::getGame()->getGui()->getSourceEditWindow();
ASSERT(wndSrcedt != 0L);
wndSrcedt->showWindow(false);
}
}
break;
case SMODE_SELLIST:
{
SourceListWindow* wndMlist = Game::getGame()->getGui()->getMagicListWindow();
ASSERT(wndMlist != 0L);
if(wndMlist->isDone()) // 完了検知
{
// 選択したマ法をソースエディタにセット
const Source* source = wndMlist->getSelectedSource();
SourceEditWindow* wndSrcedt = Game::getGame()->getGui()->getSourceEditWindow();
ASSERT(wndSrcedt != 0L);
if(source != 0L) // リストを選択した
{
// 種別を更新
_srckind = source->getSourceKind();
// 関数呼び出し補完文字列
VcString strFuncCall;
switch(_srckind)
{
case SourceDef::SRCKIND_JS:
strFuncCall.set("();");
break;
case SourceDef::SRCKIND_SS:
strFuncCall.set(" a o.");
break;
}
// ソース入力ウインドウに設定する
VcString strSource(*source->getName() + strFuncCall);
wndSrcedt->setup(SourceEditWindow::ACTMODE_LIVE, &strSource);
if(_isDirectListMode && (Game::getGame()->getMyParty()->pcUnit(MyParty::PC_MY) != 0L))
{
// 自キャラを得る
Spirit* sprt = Game::getGame()->getMyParty()->pcUnit(MyParty::PC_MY)->spirit();
ASSERT(sprt != 0L);
// ソースコードを得る
VcString code;
wndSrcedt->takeSourceText(&code);
// ソウマ実行
Spirit::SoumaBehaviorParam sbp(
&code,
_srckind,
source->isUserCustomized() );
sprt->startBehavior(Spirit::BEHV_SOUMA, &sbp);
// フォーカスカーサーの操作をしばらく禁止する
FocusCursor* fccsr = Game::getGame()->getGui()->getFocusCursor();
ASSERT(fccsr != 0L);
fccsr->setPreventTapCounter(30.0f); // 30 フレーム待て
}
}
if(_isDirectListMode)
{
// 以前のモードへ戻る
changePrevMode();
}
else
{
// ソース入力ウインドウを開く
wndSrcedt->showWindow(true);
_smode = SMODE_TYPING;
}
// ソースリストウインドウを閉じる
wndMlist->showWindow(false);
}
}
break;
}
}
