示例#1
0
void PickupGrantUpdate::operator delete(void *aPtr)
{
	killpool.free(aPtr);
}
示例#2
0
void Weapon::operator delete(void *aPtr)
{
	pool.free(aPtr);
}
示例#3
0
void Pickup::operator delete(void *aPtr)
{
	pool.free(aPtr);
}
示例#4
0
void Collidable::operator delete(void *aPtr)
{
	pool.free(aPtr);
}
示例#5
0
  BoundedResult
  cost_bounded_search(Node *start_node,
                      const Cost bound)
  {
    if (start_node->get_state() == domain.get_goal_state()) {
      BoundedResult res(start_node);
      assert(res.is_goal());
      return res;
    }

    std::vector<Node *> succs;
    domain.compute_successors(*start_node, succs, node_pool);

    num_expanded += 1;
    num_generated += succs.size();


#ifdef OUTPUT_SEARCH_PROGRESS
      if (get_num_expanded() % 1000000 == 0) {
        std::cerr << "progress update:" << std::endl;
        std::cerr << get_num_expanded() << " total nodes expanded" << std::endl
                  << get_num_generated() << " total nodes generated" << std::endl;
      }
#endif


    boost::optional<Cost> new_cutoff;
    
    for (unsigned i = 0; i < succs.size(); i += 1) {
      Node *succ = succs[i];

#ifdef IDA_STAR_CYCLE_CHECKING
      if (start_node->is_descendent_of(succ)) {
        node_pool.free(succ);
        continue;
      }
#endif      

      domain.compute_heuristic(*start_node, *succ);

      if (succ->get_f() <= bound) {
        BoundedResult res = cost_bounded_search(succ, bound);
        if (res.is_goal()) {
          assert(!res.is_cutoff());
          assert(!res.is_failure());
          return res;
        }
        else if (res.is_cutoff()) {
          assert(!res.is_goal());
          assert(!res.is_failure());

          if (new_cutoff)
            new_cutoff = std::min(*new_cutoff, res.get_cutoff());
          else
            new_cutoff = res.get_cutoff();
        }
      }
      else {
        if (new_cutoff)
          new_cutoff = std::min(*new_cutoff, succ->get_f());
        else
          new_cutoff = succ->get_f();
      }

      node_pool.free(succ);
    } /* end for */

    if (new_cutoff) {
      BoundedResult res(*new_cutoff);
      assert(res.is_cutoff());
      assert(!res.is_goal());
      assert(!res.is_failure());
      return res;
    }
    else {
      // std::cerr << "returning failure!" << std::endl;
      BoundedResult res;
      assert(res.is_failure());
      assert(!res.is_cutoff());
      assert(!res.is_failure());
      return res;
    }
  }
示例#6
0
void VarScope::operator delete(void *aPtr)
{
	varscopepool.free(aPtr);
}
示例#7
0
void Spawner::operator delete(void *aPtr)
{
	pool.free(aPtr);
}
示例#8
0
void VarString::operator delete(void *aPtr)
{
	varstringpool.free(aPtr);
}
示例#9
0
void VarFloat::operator delete(void *aPtr)
{
	varfloatpool.free(aPtr);
}
示例#10
0
void VarInteger::operator delete(void *aPtr)
{
	varintegerpool.free(aPtr);
}
示例#11
0
void VarCommand::operator delete(void *aPtr)
{
	varcommandpool.free(aPtr);
}
示例#12
0
void SimpleParticle::operator delete(void* block)
{
	particlePool.free(block);
}