static int obj_cond(int op, int obj, int arg)
{
switch(op) {
case 0:cret(in_scope(obj)); /* Present--
Do we want to use visible here?? */
case 1:cret(is_within(obj,1000,1)); /* IsWearing */
case 2:cret(is_within(obj,1,1));
/* if (PURE_WEAR) return (it_loc(obj)==1); else */
case 3:cret(it_loc(obj)==0); /* Nowhere */
case 4:cret(it_loc(obj)!=0);
case 5:cret(!player_has(obj) && in_scope(obj));
case 6:cret(it_loc(obj)==arg);
case 7:cret(it_on(obj));
case 8:cret(!it_on(obj));
case 9:cret(it_open(obj));
case 10:cret(!it_open(obj));
case 11:cretn(obj,locked);
case 12:cret(!tnoun(obj) || !noun[obj-first_noun].locked);
case 13:cretn(obj,edible);
case 14:cretn(obj,drinkable);
case 15:cretn(obj,poisonous);
case 16:cretn(obj,movable);
default:
writeln("INTERNAL ERROR: Bad obj_cond value.");
return 2;
}
}
void tipc_net_route_msg(struct sk_buff *buf)
{
struct tipc_msg *msg;
u32 dnode;
if (!buf)
return;
msg = buf_msg(buf);
msg_incr_reroute_cnt(msg);
if (msg_reroute_cnt(msg) > 6) {
if (msg_errcode(msg)) {
msg_dbg(msg, "NET>DISC>:");
buf_discard(buf);
} else {
msg_dbg(msg, "NET>REJ>:");
tipc_reject_msg(buf, msg_destport(msg) ?
TIPC_ERR_NO_PORT : TIPC_ERR_NO_NAME);
}
return;
}
msg_dbg(msg, "tipc_net->rout: ");
dnode = msg_short(msg) ? tipc_own_addr : msg_destnode(msg);
if (in_scope(dnode, tipc_own_addr)) {
if (msg_isdata(msg)) {
if (msg_mcast(msg))
tipc_port_recv_mcast(buf, NULL);
else if (msg_destport(msg))
tipc_port_recv_msg(buf);
else
net_route_named_msg(buf);
return;
}
switch (msg_user(msg)) {
case ROUTE_DISTRIBUTOR:
tipc_cltr_recv_routing_table(buf);
break;
case NAME_DISTRIBUTOR:
tipc_named_recv(buf);
break;
case CONN_MANAGER:
tipc_port_recv_proto_msg(buf);
break;
default:
msg_dbg(msg,"DROP/NET/<REC<");
buf_discard(buf);
}
return;
}
msg_dbg(msg, "NET>SEND>: ");
tipc_link_send(buf, dnode, msg_link_selector(msg));
}
void FastVolume::propagate(int threshold, int dist, int max_depth, int times){
// cur_gen++;
int cur, cur_val;//, cursor_idx;
std::vector<int> res;
int cur_idx;
for(int iter = 0; iter < times; iter++){
res.clear();
//every point
for(std::vector<int>::iterator i = markers.begin(); i != markers.end(); i++){
cur = *i;
//if(!GEN(mask[cur]))mask[cur]=cur_gen | MSK; //mark it as mask
if(mask[cur] & TRU)continue;
record_operation(cur, (mask[cur] - (MASK & mask[cur])) | MSK);
if(!in_scope(cur)){ //wait a bit
record_operation(cur, mask[cur] | BDR);
res.push_back(cur);
}else{ //in scope, can go
//every neighbour
for(int j = 0; j < 6; j++){
cur_idx = cur + neighbours[j];
cur_val = vol[cur_idx];
if(MASK & mask[cur_idx]){
continue;
//mask[cur_idx] -= (BDR & (mask[cur_idx]);
};
//try lookahead first; proceed as normal if unsuccessful;
if(!lookahead(this, res, cur, neighbours[j], dist, cur_gen)){
if((!((ZRO | TRU | MASK) & mask[cur_idx])) && (cur_val < threshold) && ((depth[cur_idx] < max_depth) || depth == 0)){
if(!(BDR & mask[cur_idx])){
record_operation(cur_idx, mask[cur_idx] | BDR);
res.push_back(cur_idx);
};
};
};
};
}; //in scope
};
markers = res;
printf("Markers %d\n", (int)markers.size());
};
//if(cur_gen > (GEN_MAX-3))downshift(MASK);
//reseed();
record_done();
};
void FastVolume::reseed(){
int i, j, cur;
markers.clear();
for(i = getOffset(1,1,1); i < getOffset(254,254,254); i++){
if(BDR & mask[i]){
mask[i] -= BDR; mask[i] |= MSK; //just make sure we seed what we seed
};
if((mask[i] & MASK) && !(mask[i] & (ZRO|TRU))){
//iterate neighbours
for(j = 0; j < 6; j++){
cur = i+neighbours[j];
if(!(mask[cur]&(MASK | ZRO | TRU)) && in_scope(cur)){ //if any pixel around is not mask, then...
mask[i] |= BDR; //we don't care if it is also a mask
markers.push_back(i);
break; //next point, please
}; //if(mask[cur]==0)
}; //for(j = 0; j < 6; j++)
};
};
};
void tipc_disc_recv_msg(struct sk_buff *buf, struct bearer *b_ptr)
{
struct link *link;
struct tipc_media_addr media_addr;
struct tipc_msg *msg = buf_msg(buf);
u32 dest = msg_dest_domain(msg);
u32 orig = msg_prevnode(msg);
u32 net_id = msg_bc_netid(msg);
u32 type = msg_type(msg);
msg_get_media_addr(msg,&media_addr);
msg_dbg(msg, "RECV:");
buf_discard(buf);
if (net_id != tipc_net_id)
return;
if (!tipc_addr_domain_valid(dest))
return;
if (!tipc_addr_node_valid(orig))
return;
if (orig == tipc_own_addr) {
if (memcmp(&media_addr, &b_ptr->publ.addr, sizeof(media_addr)))
disc_dupl_alert(b_ptr, tipc_own_addr, &media_addr);
return;
}
if (!in_scope(dest, tipc_own_addr))
return;
if (is_slave(tipc_own_addr) && is_slave(orig))
return;
if (is_slave(orig) && !in_own_cluster(orig))
return;
if (in_own_cluster(orig)) {
/* Always accept link here */
struct sk_buff *rbuf;
struct tipc_media_addr *addr;
struct tipc_node *n_ptr = tipc_node_find(orig);
int link_fully_up;
dbg(" in own cluster\n");
if (n_ptr == NULL) {
n_ptr = tipc_node_create(orig);
if (!n_ptr)
return;
}
spin_lock_bh(&n_ptr->lock);
link = n_ptr->links[b_ptr->identity];
if (!link) {
dbg("creating link\n");
link = tipc_link_create(b_ptr, orig, &media_addr);
if (!link) {
spin_unlock_bh(&n_ptr->lock);
return;
}
}
addr = &link->media_addr;
if (memcmp(addr, &media_addr, sizeof(*addr))) {
if (tipc_link_is_up(link) || (!link->started)) {
disc_dupl_alert(b_ptr, orig, &media_addr);
spin_unlock_bh(&n_ptr->lock);
return;
}
warn("Resetting link <%s>, peer interface address changed\n",
link->name);
memcpy(addr, &media_addr, sizeof(*addr));
tipc_link_reset(link);
}
link_fully_up = (link->state == WORKING_WORKING);
spin_unlock_bh(&n_ptr->lock);
if ((type == DSC_RESP_MSG) || link_fully_up)
return;
rbuf = tipc_disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr);
if (rbuf != NULL) {
msg_dbg(buf_msg(rbuf),"SEND:");
b_ptr->media->send_msg(rbuf, &b_ptr->publ, &media_addr);
buf_discard(rbuf);
}
}
}
void tipc_disc_recv_msg(struct sk_buff *buf)
{
struct bearer *b_ptr = (struct bearer *)TIPC_SKB_CB(buf)->handle;
struct link *link;
struct tipc_media_addr media_addr;
struct tipc_msg *msg = buf_msg(buf);
u32 dest = msg_dest_domain(msg);
u32 orig = msg_prevnode(msg);
u32 net_id = msg_bc_netid(msg);
u32 type = msg_type(msg);
msg_get_media_addr(msg,&media_addr);
msg_dbg(msg, "RECV:");
buf_discard(buf);
if (net_id != tipc_net_id)
return;
if (!tipc_addr_domain_valid(dest))
return;
if (!tipc_addr_node_valid(orig))
return;
if (orig == tipc_own_addr)
return;
if (!in_scope(dest, tipc_own_addr))
return;
if (is_slave(tipc_own_addr) && is_slave(orig))
return;
if (is_slave(orig) && !in_own_cluster(orig))
return;
if (in_own_cluster(orig)) {
/* Always accept link here */
struct sk_buff *rbuf;
struct tipc_media_addr *addr;
struct node *n_ptr = tipc_node_find(orig);
int link_up;
dbg(" in own cluster\n");
if (n_ptr == NULL) {
n_ptr = tipc_node_create(orig);
}
if (n_ptr == NULL) {
warn("Memory squeeze; Failed to create node\n");
return;
}
spin_lock_bh(&n_ptr->lock);
link = n_ptr->links[b_ptr->identity];
if (!link) {
dbg("creating link\n");
link = tipc_link_create(b_ptr, orig, &media_addr);
if (!link) {
spin_unlock_bh(&n_ptr->lock);
return;
}
}
addr = &link->media_addr;
if (memcmp(addr, &media_addr, sizeof(*addr))) {
char addr_string[16];
warn("New bearer address for %s\n",
addr_string_fill(addr_string, orig));
memcpy(addr, &media_addr, sizeof(*addr));
tipc_link_reset(link);
}
link_up = tipc_link_is_up(link);
spin_unlock_bh(&n_ptr->lock);
if ((type == DSC_RESP_MSG) || link_up)
return;
rbuf = tipc_disc_init_msg(DSC_RESP_MSG, 1, orig, b_ptr);
if (rbuf != NULL) {
msg_dbg(buf_msg(rbuf),"SEND:");
b_ptr->media->send_msg(rbuf, &b_ptr->publ, &media_addr);
buf_discard(rbuf);
}
}
}
