int WriteDataMessage::build(char* data, int32_t len)
{
if (has_lease_ == true)
{
ds_.push_back(ULONG_LONG_MAX);
ds_.push_back(static_cast<uint64_t>(version_));
ds_.push_back(static_cast<uint64_t>(lease_));
}
if (set_object(&data, &len, &write_data_info_, sizeof(WriteDataInfo)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_vint64(&data, &len, ds_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (write_data_info_.length_ > 0)
{
if (set_object(&data, &len, data_, write_data_info_.length_) == TFS_ERROR)
{
return TFS_ERROR;
}
}
// reparse, avoid push verion&lease again when clone twice;
has_lease_ = parse_special_ds(ds_, version_, lease_);
return TFS_SUCCESS;
}
int SetDataserverMessage::build(char* data, int32_t len)
{
if (ds_ == NULL)
{
return TFS_ERROR;
}
if (set_object(&data, &len, reinterpret_cast<void**> (ds_), sizeof(DataServerStatInfo))
== TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, has_block_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (has_block_)
{
// size
int32_t size = blocks_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (int32_t i = 0; i < size; i++)
{
if (set_object(&data, &len, &(blocks_.at(i)), BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
}
return TFS_SUCCESS;
}
int UpdateBlockInfoMessage::build(char* data, int32_t len)
{
if (set_int32(&data, &len, block_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int64(&data, &len, server_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t have_block = 0;
if (block_info_ != NULL)
{
have_block = 1;
}
if (set_int32(&data, &len, have_block) == TFS_ERROR)
{
return TFS_ERROR;
}
if (block_info_ != NULL)
{
if (set_object(&data, &len, block_info_, BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (set_int32(&data, &len, repair_) == TFS_ERROR)
{
return TFS_ERROR;
}
// SdbmStat
int32_t have_sdbm = 0;
if (db_stat_ != NULL)
{
have_sdbm = 1;
}
if (set_int32(&data, &len, have_sdbm) == TFS_ERROR)
{
return TFS_ERROR;
}
if (db_stat_ != NULL)
{
if (set_object(&data, &len, db_stat_, sizeof(SdbmStat)) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
value& value::operator=(const value& aOther) {
switch (aOther.mType)
{
case CHAR_T:
set_char(aOther.mChar);
break;
case BOOL_T:
set_bool(aOther.mBool);
break;
case UNSIGNED_T:
set_unsigned(aOther.mUnsigned);
break;
case SIGNED_T:
set_signed(aOther.mSigned);
break;
case FLOAT_T:
set_float(aOther.mFloat);
break;
case POINTER_T:
set_pointer(aOther.mPointer);
break;
case STRING_T:
set_string(*static_cast<const c_string*>(aOther.mPointer));
break;
case ARRAY_T:
set_array(*static_cast<const container<value>*>(aOther.mPointer));
break;
case OBJECT_T:
set_object(*static_cast<const std::map<c_string, value>*>(aOther.mPointer));
break;
default:
break;
}
return *this;
}
int CompactBlockCompleteMessage::build(char* data, int32_t len)
{
if (block_info_ == NULL)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, block_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, success_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int64(&data, &len, server_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, flag_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_vint64(&data, &len, ds_list_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_object(&data, &len, block_info_, BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
static void put_status(t_info *info)
{
t_param p;
int x;
int y;
for (x = 0; x < info->x - 2; x++)
for (y = 0; y < info->y - 2; y++)
if (info->status[x][y] >= 0)
{
p.gfx = STATUS;
p.x = (x + 1) * FLOOR_X;
p.y = (y + 1) * FLOOR_Y;
if (info->status[x][y] == BROADCAST)
p.anim = 0;
else if (info->status[x][y] == LEVELUP_PROGRESS)
p.anim = 2;
else if (info->status[x][y] == LEVELUP)
p.anim = 8;
else if (info->status[x][y] == TAKE_OBJ)
p.anim = 20;
else if (info->status[x][y] == DROP_OBJ)
p.anim = 9;
if (info->status[x][y] != LEVELUP_PROGRESS)
info->status[x][y] = -1;
set_object(info->gfx, &p);
}
}
int ReplicateInfoMessage::build(char* data, int32_t len)
{
int32_t size = replicating_map_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (REPL_BLOCK_MAP::const_iterator it = replicating_map_.begin(); it != replicating_map_.end(); ++it)
{
if (set_int32(&data, &len, static_cast<int32_t> (it->first)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_object(&data, &len, reinterpret_cast<void*> (const_cast<ReplBlock*>(&it->second)), sizeof(ReplBlock)) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (set_counter_map(&data, &len, source_ds_counter_, source_ds_counter_.size()))
{
return TFS_ERROR;
}
if (set_counter_map(&data, &len, dest_ds_counter_, dest_ds_counter_.size()))
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
int RenameFileMessage::build(char* data, int32_t len)
{
if (has_lease_ == true)
{
ds_.push_back(ULONG_LONG_MAX);
ds_.push_back(static_cast<uint64_t> (version_));
ds_.push_back(static_cast<uint64_t> (lease_id_));
}
if (set_object(&data, &len, &rename_file_info_, sizeof(RenameFileInfo)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_vint64(&data, &len, ds_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, option_flag_) == TFS_ERROR)
{
return TFS_ERROR;
}
has_lease_ = parse_special_ds(ds_, version_, lease_id_);
return TFS_SUCCESS;
}
int AccessStatInfoMessage::set_counter_map(char** data, int32_t* len, const COUNTER_TYPE & map, int32_t from_row,
int32_t return_row, int32_t size)
{
if (set_int32(data, len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
if (size <= 0)
{
return TFS_SUCCESS;
}
int count = 0;
COUNTER_TYPE::const_iterator it = map.begin();
for (; it != map.end(); ++it)
{
count++;
if (count <= from_row)
{
continue;
}
if (count > from_row + return_row)
{
break;
}
if (set_int32(data, len, static_cast<int32_t> (it->first)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_object(data, len, reinterpret_cast<void*> (const_cast<Throughput*>(&it->second)), sizeof(Throughput)) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
void ShipGoalsDlg::OnSelchangeObject10()
{
UpdateData(TRUE);
set_object(9);
m_subsys[9] = m_dock2[9] = 0;
UpdateData(FALSE);
}
int BlockWriteCompleteMessage::build(char* data, int32_t len)
{
if (block_info_ == NULL)
{
return TFS_ERROR;
}
if (set_int64(&data, &len, server_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_object(&data, &len, block_info_, BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, lease_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, write_complete_status_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, unlink_flag_) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
int WriteInfoBatchMessage::build(char* data, int32_t len)
{
if (set_object(&data, &len, &write_data_info_, sizeof(WriteDataInfo)) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t have_block = 0;
if (block_info_ != NULL)
{
have_block = 1;
}
if (set_int32(&data, &len, have_block) == TFS_ERROR)
{
return TFS_ERROR;
}
if (block_info_ != NULL)
{
if (set_object(&data, &len, block_info_, BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
int32_t size = meta_list_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t i = 0;
for (i = 0; i < size; i++)
{
if (set_object(&data, &len, &(meta_list_.at(i)), RAW_META_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (set_int32(&data, &len, cluster_) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
int MasterAndSlaveHeartMessage::build(char* data, int32_t len)
{
if (set_object(&data, &len, &ns_identity_, sizeof(ns_identity_)) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
int RespListBlockMessage::build(char* data, int32_t len)
{
int32_t size;
if (set_int32(&data, &len, status_type_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (status_type_ & LB_BLOCK)
{
if (set_vint32(&data, &len, blocks_) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (status_type_ & LB_PAIRS)
{
map<uint32_t, vector<uint32_t> >::iterator mit;
size = block_pairs_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (mit = block_pairs_.begin(); mit != block_pairs_.end(); mit++)
{
if (set_int32(&data, &len, mit->first) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_vint32(&data, &len, mit->second) == TFS_ERROR)
{
return TFS_ERROR;
}
}
}
if (status_type_ & LB_INFOS)
{
map<uint32_t, BlockInfo*>::iterator mit;
size = block_infos_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
for (mit = block_infos_.begin(); mit != block_infos_.end(); mit++)
{
if (set_object(&data, &len, mit->second, BLOCKINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
}
return TFS_SUCCESS;
}
int ClientCmdMessage::build(char *data, int32_t len)
{
if (set_object(&data, &len, &client_cmd_info_, sizeof(ClientCmdInfo)) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
obj_shape::obj_shape(string *name, double scale)
{
char *cname = (char*) malloc(200);
strcpy (cname, name->c_str());
if((object = InitObject(cname)) == (Object*)NULL) {
printf("Cannot load the object!\n");
}
set_object(object);
this->scale = scale;
}
int WriteRawDataMessage::build(char* data, int32_t len)
{
if (set_object(&data, &len, &write_data_info_, sizeof(WriteDataInfo)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (write_data_info_.length_ > 0)
{
if (set_object(&data, &len, data_, write_data_info_.length_) == TFS_ERROR)
{
return TFS_ERROR;
}
}
if (set_int32(&data, &len, flag_) == TFS_ERROR)
{
return TFS_ERROR;
}
return TFS_SUCCESS;
}
void cmd_set(Ttoken *t) {
char *name;
int x;
int y;
int dir = NO_CHANGE;
name = t->word;
t = (Ttoken *)t->next;
if (!strncmp(name, "line", 4)) {
// special handling of lines
Tscript_object *s, *d;
int sx, sy, dx, dy;
if (t == NULL) return;
s = get_object(t->word);
if (s == NULL) return;
t = (Ttoken *)t->next; if (t == NULL) return;
sx = atoi(t->word);
t = (Ttoken *)t->next; if (t == NULL) return;
sy = atoi(t->word);
t = (Ttoken *)t->next; if (t == NULL) return;
d = get_object(t->word);
if (d == NULL) return;
t = (Ttoken *)t->next; if (t == NULL) return;
dx = atoi(t->word);
t = (Ttoken *)t->next; if (t == NULL) return;
dy = atoi(t->word);
set_line(name, s, sx, sy, d, dx, dy);
}
else {
if (t->word[0] == '*') x = NO_CHANGE;
else x = atoi(t->word);
t = (Ttoken *)t->next;
if (t->word[0] == '*') y = NO_CHANGE;
else y = atoi(t->word);
t = (Ttoken *)t->next;
if (t != NULL) {
if (!stricmp(t->word, "right")) dir = 1;
else if (!stricmp(t->word, "rotate")) dir = 2;
else dir = 0;
}
set_object(name, x, y, dir);
}
}
QObjectBrowserControl::QObjectBrowserControl(QWidget *parent) : QWidget(parent),
ui (new Ui_qobjectbrowser) {
ui->setupUi(this);
m_obj=0;
connect(ui->update_children_button,SIGNAL(clicked()),this,SLOT(on_update_children()));
connect(ui->update_properties_button,SIGNAL(clicked()),this,SLOT(on_update_properties()));
connect(ui->parent_button,SIGNAL(clicked()),this,SLOT(on_up_to_parent()));
connect(ui->children_table,SIGNAL(cellDoubleClicked (int,int)),this,SLOT(on_children_table_cell_clicked(int,int)));
set_object(parent);
}
int MasterAndSlaveHeartResponseMessage::build(char* data, int32_t len)
{
if (set_object(&data, &len, &ns_identity_, sizeof(ns_identity_)) == TFS_ERROR)
{
return TFS_ERROR;
}
if (ns_identity_.flags_ == HEART_GET_DATASERVER_LIST_FLAGS_YES)
{
if (set_vint64(&data, &len, ds_list_) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
void
EditorInputCenter::process_right_click() {
switch (Editor::current()->tileselect.input_type) {
case EditorInputGui::IP_TILE: {
dragging = true;
dragging_right = true;
drag_start = sector_pos;
update_tile_selection();
} break;
case EditorInputGui::IP_NONE:
case EditorInputGui::IP_OBJECT:
set_object();
break;
default:
break;
}
}
static void put_object(t_info *info)
{
t_param p;
int x;
int y;
int z;
for (x = 0; x < info->x - 2; x++)
for (y = 0; y < info->y - 2; y++)
for (z = 0; z < NB_OBJECT; z++)
if (info->object[x][y][z])
{
p.gfx = OBJECT;
p.x = (x + 1) * FLOOR_X;
p.y = (y + 1) * FLOOR_Y;
p.anim = z;
set_object(info->gfx, &p);
}
}
static int setvar(const char *varname, const char *val) {
int status = STAT_SET_FAILED; /* pessimistic assumption */
object_query_t *resp = NULL;
object_query_t *req = NULL;
/* Pragmatic do { ... } while (0) loop allowing break to cleanup */
do {
/* Create SET_OBJECT request */
req = object_query_create(SET_OBJECT_REQUEST, FORM_POST);
if (NULL == req)
break;
if (NULL == set_object_add(req, varname, val))
break;
/* Send SET_OBJECT request */
resp = set_object(req);
if (NULL == resp)
break;
/* Check if setting was done */
if (1 > object_query_size(resp)) {
status = STAT_SET_UNKNOWN;
break;
}
status = STAT_SET_HANDLED; /* success */
} while (0); /* end of pragmatic loop, break target */
/* Cleanup */
if (NULL != req)
object_query_destroy(req);
if (NULL != resp)
object_query_destroy(resp);
return status;
}
static void put_clients(t_info *info, int anim)
{
t_list *t;
t_param p;
sort_client_list(&info->clients);
t = info->clients;
while (t)
{
if (!anim)
put_direction_to_anim(t->data);
p.x = (CLIENT(t->data)->x + 1) * FLOOR_X;
p.y = CLIENT(t->data)->y * FLOOR_Y;
p.anim = CLIENT(t->data)->anim
+ (16 * (CLIENT(t->data)->level - 1));
p.gfx = BIBI + (CLIENT(t->data)->team_id % NB_CHARACTER);
set_object(info->gfx, &p);
t = t->next;
}
}
int RespListBitMapMessage::build(char* data, int32_t len)
{
if (set_int32(&data, &len, uuse_len_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (set_int32(&data, &len, ubitmap_len_) == TFS_ERROR)
{
return TFS_ERROR;
}
if (ubitmap_len_ > 0)
{
if (set_object(&data, &len, data_, ubitmap_len_) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
/*-------------------------------------------------------------------------*\
* Method: e = nextedge(self, prev)
* Retrieves next edge of a node.
* Returns the next edge of the given node. With nil as prev the first
* edge is returned.
* Example:
* first = n:nextedge(nil)
* second = n:nextedge(first)
* third = n:nextedge(second)
\*-------------------------------------------------------------------------*/
static int gr_nextedge(lua_State *L)
{
int rv;
char sbuf[32];
Agraph_t *g;
Agedge_t *e;
gr_edge_t *ud_e;
gr_node_t *ud_n = tonode(L, 1, STRICT);
g = agroot(ud_n->n);
if (lua_isnil(L, 2)){
e = agfstedge(g, ud_n->n);
} else {
ud_e = toedge(L, 2, STRICT);
e = agnxtedge(g, ud_e->e, ud_n->n);
}
if (!e){
/* no more edges */
lua_pushnil(L);
return 1;
} else {
/* Check whether userdata exists .. */
rv = get_object(L, e);
if (rv == 1){
/* .. yes: return it */
return rv;
} else {
/* .. no: create it */
lua_pop(L, rv);
ud_e = lua_newuserdata(L, sizeof(gr_edge_t));
ud_e->e = e;
sprintf(sbuf, "edge@%lu", (unsigned long) AGID(e));
ud_e->name = strdup(sbuf);
ud_e->type = AGEDGE;
ud_e->status = ALIVE;
set_object(L, e);
return new_edge(L);
}
}
}
int BlockFileInfoMessage::build(char* data, int32_t len)
{
if (set_int32(&data, &len, block_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t size = fileinfo_list_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t i = 0;
for (i = 0; i < size; i++)
{
FileInfo* file_info = fileinfo_list_[i];
if (set_object(&data, &len, reinterpret_cast<void*> (file_info), FILEINFO_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
static int gr_nextinout(lua_State *L, edge_first_iter_t *fst, edge_next_iter_t *nxt)
{
int rv;
Agedge_t *e;
char sbuf[32];
gr_edge_t *ud_e;
gr_node_t *ud_n = tonode(L, 1, STRICT);
Agraph_t *g = agroot(ud_n->n);
if (lua_isnil(L, 2))
e = fst(g, ud_n->n);
else {
ud_e = toedge(L, 2, STRICT);
e = nxt(g, ud_e->e);
}
if (!e){
/* no more nodes */
lua_pushnil(L);
return 1;
} else {
/* Check whether userdata exists .. */
rv = get_object(L, e);
if (rv == 1)
/* .. yes: return it */
return rv;
else {
/* .. no: create it */
lua_pop(L, rv);
ud_e = lua_newuserdata(L, sizeof(gr_edge_t));
ud_e->e = e;
sprintf(sbuf, "edge@%lu", (unsigned long) AGID(e));
ud_e->name = strdup(sbuf);
ud_e->type = AGEDGE;
set_object(L, e);
return new_edge(L);
}
}
}
int BlockRawMetaMessage::build(char* data, int32_t len)
{
if (set_int32(&data, &len, block_id_) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t size = raw_meta_list_.size();
if (set_int32(&data, &len, size) == TFS_ERROR)
{
return TFS_ERROR;
}
int32_t i = 0;
for (i = 0; i < size; i++)
{
RawMeta raw_meta = raw_meta_list_[i];
if (set_object(&data, &len, reinterpret_cast<void*> (&raw_meta), RAW_META_SIZE) == TFS_ERROR)
{
return TFS_ERROR;
}
}
return TFS_SUCCESS;
}
void do_set(char *cmd, t_player *player, int fd)
{
char *obj;
if ((obj = get_name(cmd)) == NULL)
send_ko(fd);
if (strcmp(obj, "nourriture\n") == 0)
ret_food(fd, player->posx, player->posy);
else if (strcmp(obj, "linemate\n") == 0)
set_object(player, 1, fd);
else if (strcmp(obj, "deraumere\n") == 0)
set_object(player, 2, fd);
else if (strcmp(obj, "sibur\n") == 0)
set_object(player, 3, fd);
else if (strcmp(obj, "mendiane\n") == 0)
set_object(player, 4, fd);
else if (strcmp(obj, "phiras\n") == 0)
set_object(player, 5, fd);
else if (strcmp(obj, "thystame\n") == 0)
set_object(player, 6, fd);
else
send_ko(fd);
}
