C++ Item::GetId方法代码示例

//==============================================================================
void GameServer::HandlePutItem_(const QVariantMap& request, QVariantMap& response)
{
  if (!testingStageActive_)
  {
    WriteResult_(response, EFEMPResult::BAD_ACTION);
    return;
  }

  if (!request["x"].toFloat() || !request["y"].toFloat())
  {
    WriteResult_(response, EFEMPResult::BAD_PLACING);
    return;
  }

  float x = request["x"].toFloat();
  float y = request["y"].toFloat();

  if (levelMap_.GetCell(x, y) != '.')
  {
    WriteResult_(response, EFEMPResult::BAD_PLACING);
    return;
  }

  Item* item = CreateActor_<Item>();
  SetActorPosition_(item, Vector2(x, y));
  SetItemDescription(request["item"].toMap(), item);
  response["id"] = item->GetId();
}

bool Filters::FilterText(const Item& item) const {
  std::vector<std::wstring> words;
  Split(text, L" ", words);
  RemoveEmptyStrings(words);

  std::vector<std::wstring> titles;
  GetAllTitles(item.GetId(), titles);

  const auto& genres = item.GetGenres();

  for (const auto& word : words) {
    auto check_strings = [&word](const std::vector<std::wstring>& v) {
      for (const auto& str : v) {
        if (InStr(str, word, 0, true) > -1)
          return true;
      }
      return false;
    };
    if (!check_strings(titles) &&
        !check_strings(genres) &&
        InStr(item.GetMyTags(), word, 0, true) == -1)
      return false;
  }

  return true;
}

//==============================================================================
void GameServer::GetItems(Creature* actor)
{
  if (actor->GetType() == EActorType::PLAYER)
  {
    for(Item* item: dynamic_cast<Player*>(actor)->items_)
    {
      item->SetPosition(actor->GetPosition());
      actors_.push_back(item);
    }
  }
  else
  {
    Item* item = CreateActor_<Item>();
    SetActorPosition_(item, actor->GetPosition());
    //storage_.GetItem(item, 22);
    storage_.GetItem(item, (item->GetId() % 31) + 1);
  }
}

//==============================================================================
void GameServer::HandlePutPlayer_(const QVariantMap& request, QVariantMap& response)
{
  if (!testingStageActive_)
  {
    WriteResult_(response, EFEMPResult::BAD_ACTION);
    return;
  }

  if (!request["x"].toFloat() || !request["y"].toFloat())
  {
    WriteResult_(response, EFEMPResult::BAD_PLACING);
    return;
  }

  float x = request["x"].toFloat();
  float y = request["y"].toFloat();

  Player* player = CreateActor_<Player>();
  SetActorPosition_(player, Vector2(x, y));

  if (IsPositionWrong(x, y, player))
  {
    KillActor_(player);
    WriteResult_(response, EFEMPResult::BAD_PLACING);
    return;
  }

  auto inventory = request["inventory"].toList();
  for (auto elem: inventory)
  {
    Item* item = CreateActor_<Item>();
    SetItemDescription(elem.toMap(), item);
    item->SetOnTheGround(false);
    player->items_.push_back(item);
    actors_.erase(std::remove(actors_.begin(), actors_.end(), item), actors_.end());
    //idToActor_.erase(item->GetId());
  }

  auto stats = request["stats"].toMap();
  for (auto s = stats.begin(); s != stats.end(); s++)
  {
    EStatConst stat = StringToStat[s.key()];
    QVariant val = s.value();
    player->SetStat(stat, val.toFloat());
  }

  if (stats.size() == 0)
  {
    player->SetSpeed(playerVelocity_);
  }

  QVariantList items;
  for (auto& elem: player->items_)
  {
    QVariantMap item;
    item["id"] = elem->GetId();
    item["name"] = elem->Getname();
    item["type"] = elem->GetTypeItem();
    item["class"] = elem->GetClass();
    item["subtype"] = elem->GetSubtype();
    item["weight"] = elem->GetWeight();
    items << item;
  }
  response["inventory"] = items;

  auto slot = request["slots"].toMap();
  QVariantMap id_slot;
  for (auto i = SlotToString.begin(); i != SlotToString.end(); i++)
  {
    if (slot.find(i.key()) != slot.end())
    {
      Item* item = CreateActor_<Item>();
      SetItemDescription(slot[i.key()].toMap(), item);
      player->items_.push_back(item);
      player->SetSlot(i.value(), item);
      player->SetStat(true, item);
      id_slot[i.key()] = item->GetId();
    }
  }
  response["slots"] = id_slot;
  response["id"] = player->GetId();

  QByteArray sid;
  do
  {
    QByteArray id = QString::number(qrand()).toLatin1();
    sid = QCryptographicHash::hash(id, QCryptographicHash::Sha1);

  } while (sidToPlayer_.find(sid) != sidToPlayer_.end());
  sid = sid.toHex();

  sidToPlayer_.insert(sid, player);
  response["sid"] = sid;
  response["fistId"] = FistId_;
}

//==============================================================================
void GameServer::HandleEquip_(const QVariantMap& request, QVariantMap& response)
{
#define BAD_ID(COND)\
  if (COND)\
  {\
    WriteResult_(response, EFEMPResult::BAD_ID);\
    return;\
  }\

  BAD_ID(request.find("id") == request.end());
  BAD_ID(!request["id"].toInt());

  QString slot = request["slot"].toString();
  if (SlotToString.find(slot) == SlotToString.end())
  {
    WriteResult_(response, EFEMPResult::BAD_SLOT);
    return;
  }

  int id = request["id"].toInt();
  auto sid = request["sid"].toByteArray();
  Player* p = sidToPlayer_[sid];

  BAD_ID((idToActor_.find(id) == idToActor_.end()) && !p->GetItemId(id));

  if (p->GetItemId(id))
  {
    //equip item from inventory
    for (auto& item: p->items_)
    {
      if (item->GetId() == id)
      {
        Item* i = p->GetSlot(SlotToString[slot]);
        if (i)
        {
          p->items_.push_back(i);
        }
        if (!p->SetSlot(SlotToString[slot], item))
        {
          WriteResult_(response, EFEMPResult::BAD_SLOT);
          return;
        }
        p->SetStat(true, item);
        p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item), p->items_.end());

        WriteResult_(response, EFEMPResult::OK);
        return;
      }
    }
    BAD_ID(true);
  }  
  else
  {
    //item is on the ground
    Item* item = dynamic_cast<Item*>(idToActor_[id]);
    BAD_ID(!item);
    Vector2 player_pos = p->GetPosition();
    Vector2 item_pos = item->GetPosition();
    float distance2 = Sqr(player_pos.x - item_pos.x) + Sqr(player_pos.y - item_pos.y);

    BAD_ID(distance2 > Sqr(pickUpRadius_))
    if (!p->SetSlot(SlotToString[slot], item))
    {
      WriteResult_(response, EFEMPResult::BAD_SLOT);
      return;
    }
    p->SetStat(true, item);
    //KillActor_(item); ???
    idToActor_.erase(item->GetId());
    actors_.erase(std::remove(actors_.begin(), actors_.end(), item), actors_.end());
  }

#undef BAD_ID
}

double StructuralStreamDriftDetector::TreeAutomaticThreshold(
  const ItemMap<unsigned>* lhs_frequency_table,
  const ItemMap<unsigned>* rhs_frequency_table) const {
  uint32_t path_count = 0;

  ItemMapCmp<unsigned> cmp_lhs(*lhs_frequency_table);
  ItemMapCmp<unsigned> cmp_rhs(*rhs_frequency_table);

  //ASSERT(cmp_lhs.freq.valid.size > cmp_rhs.freq.valid.size);

  // declare left and right list of item to be sorted and compare the index
  vector<Item> leftItems;
  vector<Item> rightItems;
  ItemMap<unsigned>::Iterator leftIter = lhs_frequency_table->GetIterator();
  ItemMap<unsigned>::Iterator rightIter = rhs_frequency_table->GetIterator();

  TreePathIterator itr(tree.get());
  vector<Item> path;
  unsigned ignored;
  while (itr.GetNext(path, ignored)) {
    ++path_count;
  }

  //push item to a vector of leftItems
  uint32_t n_value = 0;
  uint32_t maxLeftItempID = 0;
  while (leftIter.HasNext()) {
    n_value++;
    Item leftItem = leftIter.GetKey();
    if (maxLeftItempID <= leftItem.GetId())	{
      maxLeftItempID = leftItem.GetId();
    }

    leftItems.push_back(leftItem);
    leftIter.Next();
  }
  //push item to a vector of rightItems
  while (rightIter.HasNext()) {
    Item rightItem = rightIter.GetKey();
    //Only add the the compare list if item appears in both trees
    if (lhs_frequency_table->Contains(rightItem)) {
      rightItems.push_back(rightItem);
    }
    rightIter.Next();
  }

  // sort left and right array based on cmp_lhs and cmp_rhs
  sort(leftItems.begin(), leftItems.end(), cmp_lhs);
  sort(rightItems.begin(), rightItems.end(), cmp_rhs);

  // create ranking array and initialise them	(only compared with left item list)
  vector<float> leftRankedFloat(leftItems.size());
  vector<float> rightRankedFloat(leftItems.size());

  // initialise float ranking, it starts with 1.0 2.0 3.0 4.0 5.0 ....
  for (int i = 0; i < leftItems.size(); ++i) {
    leftRankedFloat[i] = i + 1;
    rightRankedFloat[i] = i + 1;
  }

  // calculate the float ranking, it may end up with sthing like 1.0 2.0 2.5 2.5 5.0 ...
  sortAVGRanking(leftItems, leftRankedFloat, cmp_lhs) ;
  sortAVGRanking(rightItems, rightRankedFloat, cmp_rhs) ;

  // create ranking array and initialise them all to zero
  vector<float> leftItemsWithRanks(maxLeftItempID + 1);
  vector<float> rightItemsWithRanks(maxLeftItempID + 1);
  for (int i = 0; i < maxLeftItempID + 1; ++i) {
    leftItemsWithRanks[i] = 0;
    rightItemsWithRanks[i] = 0;
  }

  for (int i = 0; i < maxLeftItempID; ++i)	{
    Item leftItem = leftItems.at(i);
    int mIDL = leftItem.GetId();
    leftItemsWithRanks[mIDL] = leftRankedFloat[i];
    Item rightItem = rightItems.at(i);
    int mIDR = rightItem.GetId();
    rightItemsWithRanks[mIDR] = rightRankedFloat[i];
  }

  // For calculating rho and e_cut
  double totalRankDifference = 0;
  for (int i = 1; i < maxLeftItempID + 1; ++i)	{
    totalRankDifference = totalRankDifference + (leftItemsWithRanks[i] - rightItemsWithRanks[i]) * (leftItemsWithRanks[i] - rightItemsWithRanks[i]);
  }

  double alpha = 0.01;
  double rho = 0.0;
  double z =  2.24;
  if (alpha == 0.01)
    z = 2.24;
  if (alpha == 0.005)
    z = 2.41;
  if (alpha == 0.1)
    z = 1.29;
  if(alpha == 0.25)
    z = 0.69;
  if (alpha == 0.001)
    z = 2.96;
//.........这里部分代码省略.........

TEST(StructuralStreamDriftDetector, Spearman) {
  Item::ResetBaseId();

  vector<Item> testV1(ToItemVector("0,1,2,3,4,5"));
  vector<Item> testV2(ToItemVector("0,1,2,3,4,5"));
  int maxLeftItempID = 6;
  EXPECT_EQ(edit_distance(testV1, testV2), 0);

  ItemMap<unsigned>* tst_lhs_frequency_table = new ItemMap<unsigned>();
  tst_lhs_frequency_table->Set(Item("0"), 1);
  tst_lhs_frequency_table->Set(Item("1"), 5);
  tst_lhs_frequency_table->Set(Item("2"), 6);
  tst_lhs_frequency_table->Set(Item("3"), 5);
  tst_lhs_frequency_table->Set(Item("4"), 5);
  tst_lhs_frequency_table->Set(Item("5"), 6);
  ItemMap<unsigned>* tst_rhs_frequency_table = new ItemMap<unsigned>();
  tst_rhs_frequency_table->Set(Item("0"), 1);
  tst_rhs_frequency_table->Set(Item("1"), 9);
  tst_rhs_frequency_table->Set(Item("2"), 11);
  tst_rhs_frequency_table->Set(Item("3"), 8);
  tst_rhs_frequency_table->Set(Item("4"), 8);
  tst_rhs_frequency_table->Set(Item("5"), 10);

  ItemMapCmp<unsigned> cmp_lhs(*tst_lhs_frequency_table);
  ItemMapCmp<unsigned> cmp_rhs(*tst_rhs_frequency_table);

  std::sort(testV1.begin(), testV1.end(), cmp_lhs);
  std::sort(testV2.begin(), testV2.end(), cmp_rhs);

  vector<float> leftRankedFloat(testV1.size());
  vector<float> rightRankedFloat(testV2.size());

  for (int i = 0; i < testV1.size(); i++) {
    leftRankedFloat[i] = i + 1;
    rightRankedFloat[i] = i + 1;
  }

  sortAVGRanking(testV1, leftRankedFloat, cmp_lhs);
  sortAVGRanking(testV2, rightRankedFloat, cmp_rhs);

  // create ranking array and initialise them all to zero
  vector<float> leftItemsWithRanks(maxLeftItempID + 1);
  vector<float> rightItemsWithRanks(maxLeftItempID + 1);
  for (int i = 0; i < maxLeftItempID + 1; ++i) {
    leftItemsWithRanks[i] = 0;
    rightItemsWithRanks[i] = 0;
  }

  for (int i = 0; i < maxLeftItempID; ++i)	{
    Item leftItem = testV1.at(i);
    int mIDL = leftItem.GetId();
    leftItemsWithRanks[mIDL] = leftRankedFloat[i];
    Item rightItem = testV2.at(i);
    int mIDR = rightItem.GetId();
    rightItemsWithRanks[mIDR] = rightRankedFloat[i];
  }

  for (int i = 1; i < maxLeftItempID + 1; ++i)	{
    //Item item1 = testV1.at(i);
    printf("Left Item %d is ranked at %f \n", i, leftItemsWithRanks[i]);
  }
  printf("----\n");
  for (int i = 1; i < maxLeftItempID + 1; ++i)	{
    //Item item2 = testV2.at(i);
    printf("Right Item %d is ranked at %f \n", i, rightItemsWithRanks[i]);
  }

  // For calculating rho
  double totalRankDifference = 0;
  for (int i = 1; i < maxLeftItempID + 1; ++i)	{
    totalRankDifference = totalRankDifference + (leftItemsWithRanks[i] - rightItemsWithRanks[i]) * (leftItemsWithRanks[i] - rightItemsWithRanks[i]);
  }
#ifdef DEBUG
  int counter = 6;
  double rho = 1.0 - (6.0 * totalRankDifference / (counter * (counter * counter - 1)));
  //calculated in excel by hand, RHO = 0.942857
  ASSERT(abs(rho - 0.942857) < 0.001);
#endif
}