Example #1
0
 inline reverse_iterator rend()
 {
     return reverse_iterator(begin());
 }
Example #2
0
void C4GraphCollection::Update() const {
  // update all child graphs
  for (const_iterator i = begin(); i != end(); ++i) (*i)->Update();
}
Example #3
0
void C4GraphCollection::SetMultiplier(ValueType fToVal) {
  if (fMultiplier = fToVal)
    for (iterator i = begin(); i != end(); ++i) (*i)->SetMultiplier(fToVal);
}
bool RAS_MeshSlot::Split(bool force)
{
	list<RAS_MeshSlot*>::iterator jit;
	RAS_MeshSlot *target = m_joinSlot;
	RAS_DisplayArrayList::iterator it, jt;
	iterator mit;
	size_t i, found0 = 0, found1 = 0;

	if (target && (force || !Equals(target))) {
		m_joinSlot = NULL;

		for (jit=target->m_joinedSlots.begin(); jit!=target->m_joinedSlots.end(); jit++) {
			if (*jit == this) {
				target->m_joinedSlots.erase(jit);
				found0 = 1;
				break;
			}
		}

		if (!found0)
			abort();

		for (it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
			found1 = 0;
			for (jt=target->m_displayArrays.begin(); jt!=target->m_displayArrays.end(); jt++) {
				if (*jt == *it) {
					target->m_displayArrays.erase(jt);
					target->m_endarray--;
					found1 = 1;
					break;
				}
			}

			if (!found1)
				abort();
		}

		if (target->m_displayArrays.empty() == false) {
			target->m_endvertex = target->m_displayArrays.back()->m_vertex.size();
			target->m_endindex = target->m_displayArrays.back()->m_index.size();
		}
		else {
			target->m_endvertex = 0;
			target->m_endindex = 0;
		}

		MT_Matrix4x4 ntransform = m_joinInvTransform.inverse().transposed();
		ntransform[0][3] = ntransform[1][3] = ntransform[2][3] = 0.0f;

		for (begin(mit); !end(mit); next(mit))
			for (i=mit.startvertex; i<mit.endvertex; i++)
				mit.vertex[i].Transform(m_joinInvTransform, ntransform);

		if (target->m_DisplayList) {
			target->m_DisplayList->Release();
			target->m_DisplayList = NULL;
		}

		return true;
	}

	return false;
}
Example #5
0
Tokens jsonnet_lex(const std::string &filename, const char *input)
{
    unsigned long line_number = 1;
    const char *line_start = input;

    Tokens r;

    const char *c = input;

    Fodder fodder;
    bool fresh_line = true;  // Are we tokenizing from the beginning of a new line?

    while (*c!='\0') {
        Token::Kind kind;
        std::string data;
        std::string string_block_indent;
        std::string string_block_term_indent;

        unsigned new_lines, indent;
        lex_ws(c, new_lines, indent, line_start, line_number);

        // If it's the end of the file, discard final whitespace.
        if (*c == '\0')
            break;

        if (new_lines > 0) {
            // Otherwise store whitespace in fodder.
            unsigned blanks = new_lines - 1;
            fodder.emplace_back(FodderElement::LINE_END, blanks, indent, EMPTY);
            fresh_line = true;
        }

        Location begin(line_number, c - line_start + 1);

        switch (*c) {

            // The following operators should never be combined with subsequent symbols.
            case '{':
            kind = Token::BRACE_L;
            c++;
            break;

            case '}':
            kind = Token::BRACE_R;
            c++;
            break;

            case '[':
            kind = Token::BRACKET_L;
            c++;
            break;

            case ']':
            kind = Token::BRACKET_R;
            c++;
            break;

            case ',':
            kind = Token::COMMA;
            c++;
            break;

            case '.':
            kind = Token::DOT;
            c++;
            break;

            case '(':
            kind = Token::PAREN_L;
            c++;
            break;

            case ')':
            kind = Token::PAREN_R;
            c++;
            break;

            case ';':
            kind = Token::SEMICOLON;
            c++;
            break;

            // Numeric literals.
            case '0': case '1': case '2': case '3': case '4':
            case '5': case '6': case '7': case '8': case '9':
            kind = Token::NUMBER;
            data = lex_number(c, filename, begin);
            break;

            // String literals.
            case '"': {
                c++;
                for (; ; ++c) {
                    if (*c == '\0') {
                        throw StaticError(filename, begin, "Unterminated string");
                    }
                    if (*c == '"') {
                        break;
                    }
                    if (*c == '\\' && *(c+1) != '\0') {
                        data += *c;
                        ++c;
                    }
                    if (*c == '\n') {
                        // Maintain line/column counters.
                        line_number++;
                        line_start = c+1;
                    }
                    data += *c;
                }
                c++;  // Advance beyond the ".
                kind = Token::STRING_DOUBLE;
            }
            break;

            // String literals.
            case '\'': {
                c++;
                for (; ; ++c) {
                    if (*c == '\0') {
                        throw StaticError(filename, begin, "Unterminated string");
                    }
                    if (*c == '\'') {
                        break;
                    }
                    if (*c == '\\' && *(c+1) != '\0') {
                        data += *c;
                        ++c;
                    }
                    if (*c == '\n') {
                        // Maintain line/column counters.
                        line_number++;
                        line_start = c+1;
                    }
                    data += *c;
                }
                c++;  // Advance beyond the '.
                kind = Token::STRING_SINGLE;
            }
            break;

            // Keywords
            default:
            if (is_identifier_first(*c)) {
                std::string id;
                for (; is_identifier(*c); ++c)
                    id += *c;
                if (id == "assert") {
                    kind = Token::ASSERT;
                } else if (id == "else") {
                    kind = Token::ELSE;
                } else if (id == "error") {
                    kind = Token::ERROR;
                } else if (id == "false") {
                    kind = Token::FALSE;
                } else if (id == "for") {
                    kind = Token::FOR;
                } else if (id == "function") {
                    kind = Token::FUNCTION;
                } else if (id == "if") {
                    kind = Token::IF;
                } else if (id == "import") {
                    kind = Token::IMPORT;
                } else if (id == "importstr") {
                    kind = Token::IMPORTSTR;
                } else if (id == "in") {
                    kind = Token::IN;
                } else if (id == "local") {
                    kind = Token::LOCAL;
                } else if (id == "null") {
                    kind = Token::NULL_LIT;
                } else if (id == "self") {
                    kind = Token::SELF;
                } else if (id == "super") {
                    kind = Token::SUPER;
                } else if (id == "tailstrict") {
                    kind = Token::TAILSTRICT;
                } else if (id == "then") {
                    kind = Token::THEN;
                } else if (id == "true") {
                    kind = Token::TRUE;
                } else {
                    // Not a keyword, must be an identifier.
                    kind = Token::IDENTIFIER;
                }
                data = id;

            } else if (is_symbol(*c) || *c == '#') {

                // Single line C++ and Python style comments.
                if (*c == '#' || (*c == '/' && *(c+1) == '/')) {
                    std::vector<std::string> comment(1);
                    unsigned blanks;
                    unsigned indent;
                    lex_until_newline(c, comment[0], blanks, indent, line_start, line_number);
                    auto kind = fresh_line ? FodderElement::PARAGRAPH : FodderElement::LINE_END;
                    fodder.emplace_back(kind, blanks, indent, comment);
                    fresh_line = true;
                    continue;  // We've not got a token, just fodder, so keep scanning.
                }

                // Multi-line C style comment.
                if (*c == '/' && *(c+1) == '*') {

                    unsigned margin = c - line_start;
 
                    const char *initial_c = c;
                    c += 2;  // Avoid matching /*/: skip the /* before starting the search for */.

                    while (!(*c == '*' && *(c+1) == '/')) {
                        if (*c == '\0') {
                            auto msg = "Multi-line comment has no terminating */.";
                            throw StaticError(filename, begin, msg);
                        }
                        if (*c == '\n') {
                            // Just keep track of the line / column counters.
                            line_number++;
                            line_start = c+1;
                        }
                        ++c;
                    }
                    c += 2;  // Move the pointer to the char after the closing '/'.

                    std::string comment(initial_c, c - initial_c);  // Includes the "/*" and "*/".

                    // Lex whitespace after comment
                    unsigned new_lines_after, indent_after;
                    lex_ws(c, new_lines_after, indent_after, line_start, line_number);
                    std::vector<std::string> lines;
                    if (comment.find('\n') >= comment.length()) {
                        // Comment looks like /* foo */
                        lines.push_back(comment);
                        fodder.emplace_back(FodderElement::INTERSTITIAL, 0, 0, lines);
                        if (new_lines_after > 0) {
                            fodder.emplace_back(FodderElement::LINE_END, new_lines_after - 1,
                                                indent_after, EMPTY);
                            fresh_line = true;
                        }
                    } else {
                        lines = line_split(comment, margin);
                        assert(lines[0][0] == '/');
                        // Little hack to support PARAGRAPHs with * down the LHS:
                        // Add a space to lines that start with a '*'
                        bool all_star = true;
                        for (auto &l : lines) {
                            if (l[0] != '*')
                                all_star = false;
                        }
                        if (all_star) {
                            for (auto &l : lines) {
                                if (l[0] == '*') l = " " + l;
                            }
                        }
                        if (new_lines_after == 0) {
                            // Ensure a line end after the paragraph.
                            new_lines_after = 1;
                            indent_after = 0;
                        }
                        if (!fresh_line)
                            // Ensure a line end before the comment.
                            fodder.emplace_back(FodderElement::LINE_END, 0, 0, EMPTY);
                        fodder.emplace_back(FodderElement::PARAGRAPH, new_lines_after - 1,
                                            indent_after, lines);
                        fresh_line = true;
                    }
                    continue;  // We've not got a token, just fodder, so keep scanning.
                }

                // Text block
                if (*c == '|' && *(c+1) == '|' && *(c+2) == '|' && *(c+3) == '\n') {
                    std::stringstream block;
                    c += 4; // Skip the "|||\n"
                    line_number++;
                    // Skip any blank lines at the beginning of the block.
                    while (*c == '\n') {
                        line_number++;
                        ++c;
                        block << '\n';
                    }
                    line_start = c;
                    const char *first_line = c;
                    int ws_chars = whitespace_check(first_line, c);
                    string_block_indent = std::string(first_line, ws_chars);
                    if (ws_chars == 0) {
                        auto msg = "Text block's first line must start with whitespace.";
                        throw StaticError(filename, begin, msg);
                    }
                    while (true) {
                        assert(ws_chars > 0);
                        // Read up to the \n
                        for (c = &c[ws_chars]; *c != '\n' ; ++c) {
                            if (*c == '\0')
                                throw StaticError(filename, begin, "Unexpected EOF");
                            block << *c;
                        }
                        // Add the \n
                        block << '\n';
                        ++c;
                        line_number++;
                        line_start = c;
                        // Skip any blank lines
                        while (*c == '\n') {
                            line_number++;
                            ++c;
                            block << '\n';
                        }
                        // Examine next line
                        ws_chars = whitespace_check(first_line, c);
                        if (ws_chars == 0) {
                            // End of text block
                            // Skip over any whitespace
                            while (*c == ' ' || *c == '\t') {
                                string_block_term_indent += *c;
                                ++c;
                            }
                            // Expect |||
                            if (!(*c == '|' && *(c+1) == '|' && *(c+2) == '|')) {
                                auto msg = "Text block not terminated with |||";
                                throw StaticError(filename, begin, msg);
                            }
                            c += 3;  // Leave after the last |
                            data = block.str();
                            kind = Token::STRING_BLOCK;
                            break;  // Out of the while loop.
                        }
                    }

                    break;  // Out of the switch.
                }

                const char *operator_begin = c;
                for (; is_symbol(*c) ; ++c) {
                    // Not allowed // in operators
                    if (*c == '/' && *(c+1) == '/') break;
                    // Not allowed /* in operators
                    if (*c == '/' && *(c+1) == '*') break;
                    // Not allowed ||| in operators
                    if (*c == '|' && *(c+1) == '|' && *(c+2) == '|') break;
                }
                // Not allowed to end with a + - ~ ! unless a single char.
                // So, wind it back if we need to (but not too far).
                while (c > operator_begin + 1
                       && (*(c-1) == '+' || *(c-1) == '-' || *(c-1) == '~' || *(c-1) == '!')) {
                    c--;
                }
                data += std::string(operator_begin, c);
                if (data == "$") {
                    kind = Token::DOLLAR;
                    data = "";
                } else {
                    kind = Token::OPERATOR;
                }
            } else {
                std::stringstream ss;
                ss << "Could not lex the character ";
                auto uc = (unsigned char)(*c);
                if (*c < 32)
                    ss << "code " << unsigned(uc);
                else
                    ss << "'" << *c << "'";
                throw StaticError(filename, begin, ss.str());
            }
        }

        Location end(line_number, c - line_start);
        r.emplace_back(kind, fodder, data, string_block_indent, string_block_term_indent,
                       LocationRange(filename, begin, end));
        fodder.clear();
        fresh_line = false;
    }

    Location end(line_number, c - line_start + 1);
    r.emplace_back(Token::END_OF_FILE, fodder, "", "", "", LocationRange(filename, end, end));
    return r;
}
Example #6
0
template <typename PointInT, typename PointNT, typename PointOutT> Eigen::MatrixXf
pcl::computeRSD (boost::shared_ptr<const pcl::PointCloud<PointInT> > &surface, boost::shared_ptr<const pcl::PointCloud<PointNT> > &normals,
		 const std::vector<int> &indices, double max_dist,
		 int nr_subdiv, double plane_radius, PointOutT &radii, bool compute_histogram)
{
  // Check if the full histogram has to be saved or not
  Eigen::MatrixXf histogram;
  if (compute_histogram)
    histogram = Eigen::MatrixXf::Zero (nr_subdiv, nr_subdiv);

  // Check if enough points are provided or not
  if (indices.size () < 2)
  {
    radii.r_max = 0;
    radii.r_min = 0;
    return histogram;
  }
  
  // Initialize minimum and maximum angle values in each distance bin
  std::vector<std::vector<double> > min_max_angle_by_dist (nr_subdiv);
  min_max_angle_by_dist[0].resize (2);
  min_max_angle_by_dist[0][0] = min_max_angle_by_dist[0][1] = 0.0;
  for (int di=1; di<nr_subdiv; di++)
  {
    min_max_angle_by_dist[di].resize (2);
    min_max_angle_by_dist[di][0] = +DBL_MAX;
    min_max_angle_by_dist[di][1] = -DBL_MAX;
  }

  // Compute distance by normal angle distribution for points
  std::vector<int>::const_iterator i, begin (indices.begin()), end (indices.end());
  for(i = begin+1; i != end; ++i)
  {
    // compute angle between the two lines going through normals (disregard orientation!)
    double cosine = normals->points[*i].normal[0] * normals->points[*begin].normal[0] +
                    normals->points[*i].normal[1] * normals->points[*begin].normal[1] +
                    normals->points[*i].normal[2] * normals->points[*begin].normal[2];
    if (cosine > 1) cosine = 1;
    if (cosine < -1) cosine = -1;
    double angle  = acos (cosine);
    if (angle > M_PI/2) angle = M_PI - angle; /// \note: orientation is neglected!

    // Compute point to point distance
    double dist = sqrt ((surface->points[*i].x - surface->points[*begin].x) * (surface->points[*i].x - surface->points[*begin].x) +
                        (surface->points[*i].y - surface->points[*begin].y) * (surface->points[*i].y - surface->points[*begin].y) +
                        (surface->points[*i].z - surface->points[*begin].z) * (surface->points[*i].z - surface->points[*begin].z));

    if (dist > max_dist)
      continue; /// \note: we neglect points that are outside the specified interval!

    // compute bins and increase
    int bin_d = (int) floor (nr_subdiv * dist / max_dist);
    if (compute_histogram)
    {
      int bin_a = std::min (nr_subdiv-1, (int) floor (nr_subdiv * angle / (M_PI/2)));
      histogram(bin_a, bin_d)++;
    }

    // update min-max values for distance bins
    if (min_max_angle_by_dist[bin_d][0] > angle) min_max_angle_by_dist[bin_d][0] = angle;
    if (min_max_angle_by_dist[bin_d][1] < angle) min_max_angle_by_dist[bin_d][1] = angle;
  }

  // Estimate radius from min and max lines
  double Amint_Amin = 0, Amint_d = 0;
  double Amaxt_Amax = 0, Amaxt_d = 0;
  for (int di=0; di<nr_subdiv; di++)
  {
    // combute the members of A'*A*r = A'*D
    if (min_max_angle_by_dist[di][1] >= 0)
    {
      double p_min = min_max_angle_by_dist[di][0];
      double p_max = min_max_angle_by_dist[di][1];
      double f = (di+0.5)*max_dist/nr_subdiv;
      Amint_Amin += p_min * p_min;
      Amint_d += p_min * f;
      Amaxt_Amax += p_max * p_max;
      Amaxt_d += p_max * f;
    }
  }
  float min_radius = Amint_Amin == 0 ? plane_radius : std::min (Amint_d/Amint_Amin, plane_radius);
  float max_radius = Amaxt_Amax == 0 ? plane_radius : std::min (Amaxt_d/Amaxt_Amax, plane_radius);

  // Small correction of the systematic error of the estimation (based on analysis with nr_subdiv_ = 5)
  min_radius *= 1.1;
  max_radius *= 0.9;
  if (min_radius < max_radius)
  {
    radii.r_min = min_radius;
    radii.r_max = max_radius;
  }
  else
  {
    radii.r_max = min_radius;
    radii.r_min = max_radius;
  }
  
  return histogram;
}
Example #7
0
void UARTClass::begin(const uint32_t dwBaudRate)
{
  begin(dwBaudRate, Mode_8N1);
}
Example #8
0
bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id,
	uint32 char_id, DBTradeskillRecipe_Struct *spec)
{

	// make where clause segment for container(s)
	std::string containers;
	if (some_id == 0)
		containers = StringFormat("= %u", c_type); // world combiner so no item number
	else
		containers = StringFormat("IN (%u,%u)", c_type, some_id); // container in inventory

	std::string query = StringFormat("SELECT tr.id, tr.tradeskill, tr.skillneeded, "
                                    "tr.trivial, tr.nofail, tr.replace_container, "
                                    "tr.name, tr.must_learn, tr.quest, crl.madecount "
                                    "FROM tradeskill_recipe AS tr "
                                    "INNER JOIN tradeskill_recipe_entries AS tre "
                                    "ON tr.id = tre.recipe_id "
                                    "LEFT JOIN (SELECT recipe_id, madecount "
                                    "FROM char_recipe_list WHERE char_id = %u) AS crl "
                                    "ON tr.id = crl.recipe_id "
                                    "WHERE tr.id = %lu AND tre.item_id %s AND tr.enabled "
                                    "GROUP BY tr.id",
                                    char_id, (unsigned long)recipe_id, containers.c_str());
    auto results = QueryDatabase(query);
	if (!results.Success()) {
		Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, query: %s", query.c_str());
		Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, error: %s", results.ErrorMessage().c_str());
		return false;
	}

	if(results.RowCount() != 1)
		return false;//just not found i guess..

	auto row = results.begin();
	spec->tradeskill = (SkillUseTypes)atoi(row[1]);
	spec->skill_needed	= (int16)atoi(row[2]);
	spec->trivial = (uint16)atoi(row[3]);
	spec->nofail = atoi(row[4]) ? true : false;
	spec->replace_container	= atoi(row[5]) ? true : false;
	spec->name = row[6];
	spec->must_learn = (uint8)atoi(row[7]);
	spec->quest = atoi(row[8]) ? true : false;

	if (row[9] == nullptr) {
		spec->has_learnt = false;
		spec->madecount = 0;
	} else {
		spec->has_learnt = true;
		spec->madecount = (uint32)atoul(row[9]);
	}
	spec->recipe_id = recipe_id;

	//Pull the on-success items...
	query = StringFormat("SELECT item_id,successcount FROM tradeskill_recipe_entries "
                        "WHERE successcount > 0 AND recipe_id = %u", recipe_id);
    results = QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	if(results.RowCount() < 1) {
		Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecept success: no success items returned");
		return false;
	}

	spec->onsuccess.clear();
	for(auto row = results.begin(); row != results.end(); ++row) {
		uint32 item = (uint32)atoi(row[0]);
		uint8 num = (uint8) atoi(row[1]);
		spec->onsuccess.push_back(std::pair<uint32,uint8>(item, num));
	}

    spec->onfail.clear();
	//Pull the on-fail items...
	query = StringFormat("SELECT item_id, failcount FROM tradeskill_recipe_entries "
                        "WHERE failcount > 0 AND recipe_id = %u", recipe_id);
	results = QueryDatabase(query);
	if (results.Success())
		for(auto row = results.begin(); row != results.end(); ++row) {
			uint32 item = (uint32)atoi(row[0]);
			uint8 num = (uint8) atoi(row[1]);
			spec->onfail.push_back(std::pair<uint32,uint8>(item, num));
		}

    spec->salvage.clear();

    // Don't bother with the query if TS is nofail
    if (spec->nofail)
        return true;

	// Pull the salvage list
	query = StringFormat("SELECT item_id, salvagecount "
                        "FROM tradeskill_recipe_entries "
                        "WHERE salvagecount > 0 AND recipe_id = %u", recipe_id);
    results = QueryDatabase(query);
	if (results.Success())
		for(auto row = results.begin(); row != results.begin(); ++row) {
			uint32 item = (uint32)atoi(row[0]);
			uint8 num = (uint8)atoi(row[1]);
			spec->salvage.push_back(std::pair<uint32,uint8>(item, num));
		}

	return true;
}
Example #9
0
void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac) {

	//get our packet ready, gotta send one no matter what...
	EQApplicationPacket* outapp = new EQApplicationPacket(OP_RecipeAutoCombine, sizeof(RecipeAutoCombine_Struct));
	RecipeAutoCombine_Struct *outp = (RecipeAutoCombine_Struct *)outapp->pBuffer;
	outp->object_type = rac->object_type;
	outp->some_id = rac->some_id;
	outp->unknown1 = rac->unknown1;
	outp->recipe_id = rac->recipe_id;
	outp->reply_code = 0xFFFFFFF5;	//default fail.


	//ask the database for the recipe to make sure it exists...
	DBTradeskillRecipe_Struct spec;
	if (!database.GetTradeRecipe(rac->recipe_id, rac->object_type, rac->some_id, user->CharacterID(), &spec)) {
		Log.Out(Logs::General, Logs::Error, "Unknown recipe for HandleAutoCombine: %u\n", rac->recipe_id);
		user->QueuePacket(outapp);
		safe_delete(outapp);
		return;
	}

	// Character hasn't learnt the recipe yet.
	// This shouldn't happen.
	if ((spec.must_learn&0xf) && !spec.has_learnt) {
		// Made up message for the client. Just giving a DNC is the other option.
		user->Message(4, "You need to learn how to combine these first.");
		user->QueuePacket(outapp);
		safe_delete(outapp);
		return;
	}

    //pull the list of components
	std::string query = StringFormat("SELECT tre.item_id, tre.componentcount "
                                    "FROM tradeskill_recipe_entries AS tre "
                                    "WHERE tre.componentcount > 0 AND tre.recipe_id = %u",
                                    rac->recipe_id);
    auto results = database.QueryDatabase(query);
	if (!results.Success()) {
		user->QueuePacket(outapp);
		safe_delete(outapp);
		return;
	}

	if(results.RowCount() < 1) {
		Log.Out(Logs::General, Logs::Error, "Error in HandleAutoCombine: no components returned");
		user->QueuePacket(outapp);
		safe_delete(outapp);
		return;
	}

	if(results.RowCount() > 10) {
		Log.Out(Logs::General, Logs::Error, "Error in HandleAutoCombine: too many components returned (%u)", results.RowCount());
		user->QueuePacket(outapp);
		safe_delete(outapp);
		return;
	}

	uint32 items[10];
	memset(items, 0, sizeof(items));
	uint8 counts[10];
	memset(counts, 0, sizeof(counts));

	//search for all the items in their inventory
	Inventory& user_inv = user->GetInv();
	uint8 count = 0;
	uint8 needcount = 0;

	std::list<int> MissingItems;

    uint8 needItemIndex = 0;
	for (auto row = results.begin(); row != results.end(); ++row, ++needItemIndex) {
		uint32 item = (uint32)atoi(row[0]);
		uint8 num = (uint8) atoi(row[1]);

		needcount += num;

		//because a HasItem on items with num > 1 only returns the
		//last-most slot... the results of this are useless to us
		//when we go to delete them because we cannot assume it is in a single stack.
		if (user_inv.HasItem(item, num, invWherePersonal) != INVALID_INDEX)
			count += num;
		else
			MissingItems.push_back(item);

		//dont start deleting anything until we have found it all.
		items[needItemIndex] = item;
		counts[needItemIndex] = num;
	}

	//make sure we found it all...
	if(count != needcount)
	{
		user->QueuePacket(outapp);

		safe_delete(outapp);

		user->Message_StringID(MT_Skills, TRADESKILL_MISSING_COMPONENTS);

		for(std::list<int>::iterator it = MissingItems.begin(); it != MissingItems.end(); ++it)
		{
			const Item_Struct* item = database.GetItem(*it);

			if(item)
				user->Message_StringID(MT_Skills, TRADESKILL_MISSING_ITEM, item->Name);
		}

		return;
	}

	//now we know they have everything...

	//remove all the items from the players inventory, with updates...
	int16 slot;
	for(uint8 r = 0; r < results.RowCount(); r++) {
		if(items[r] == 0 || counts[r] == 0)
			continue;	//skip empties, could prolly break here

		//we have to loop here to delete 1 at a time in case its in multiple stacks.
		for(uint8 k = 0; k < counts[r]; k++) {
			slot = user_inv.HasItem(items[r], 1, invWherePersonal);
			if (slot == INVALID_INDEX) {
				//WTF... I just checked this above, but just to be sure...
				//we cant undo the previous deletes without a lot of work.
				//so just call it quits, this shouldent ever happen anyways.
				user->QueuePacket(outapp);
				safe_delete(outapp);
				return;
			}

			const ItemInst* inst = user_inv.GetItem(slot);

			if (inst && !inst->IsStackable())
				user->DeleteItemInInventory(slot, 0, true);
			else
				user->DeleteItemInInventory(slot, 1, true);
		}
	}

	//otherwise, we found it all...
	outp->reply_code = 0x00000000;	//success for finding it...
	user->QueuePacket(outapp);
	safe_delete(outapp);


	//now actually try to make something...

	bool success = user->TradeskillExecute(&spec);

	if (success) {
		if (!spec.has_learnt && ((spec.must_learn & 0x10) != 0x10)) {
			user->Message_StringID(4, TRADESKILL_LEARN_RECIPE, spec.name.c_str());
		}
		database.UpdateRecipeMadecount(spec.recipe_id, user->CharacterID(), spec.madecount+1);
	}


	//TODO: find in-pack containers in inventory, make sure they are really
	//there, and then use that slot to handle replace_container too.
	if(success && spec.replace_container) {
//		user->DeleteItemInInventory(in_combine->container_slot, 0, true);
	}
	if (success)
		parse->EventPlayer(EVENT_COMBINE_SUCCESS, user, spec.name.c_str(), spec.recipe_id);
	else
		parse->EventPlayer(EVENT_COMBINE_FAILURE, user, spec.name.c_str(), spec.recipe_id);
}
Example #10
0
void SetList::sortByKey()
{
    qSort(begin(), end(), CompareFunctor());
}
Example #11
0
bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint32 some_id,
	uint32 char_id, DBTradeskillRecipe_Struct *spec)
{
	if (container == nullptr)
		return false;

	std::string containers;// make where clause segment for container(s)
	if (some_id == 0)
		containers = StringFormat("= %u", c_type); // world combiner so no item number
	else
		containers = StringFormat("IN (%u,%u)", c_type, some_id); // container in inventory

	//Could prolly watch for stacks in this loop and handle them properly...
	//just increment sum and count accordingly
	bool first = true;
	std::string buf2;
	uint32 count = 0;
	uint32 sum = 0;
	for (uint8 i = 0; i < 10; i++) { // <watch> TODO: need to determine if this is bound to world/item container size
		const ItemInst* inst = container->GetItem(i);
		if (!inst)
            continue;

        const Item_Struct* item = GetItem(inst->GetItem()->ID);
        if (!item)
            continue;

        if(first) {
            buf2 += StringFormat("%d", item->ID);
            first = false;
        } else
            buf2 += StringFormat(",%d", item->ID);

        sum += item->ID;
        count++;
	}

	if(count == 0)
		return false;	//no items == no recipe

	std::string query = StringFormat("SELECT tre.recipe_id "
                                    "FROM tradeskill_recipe_entries AS tre "
                                    "INNER JOIN tradeskill_recipe AS tr ON (tre.recipe_id = tr.id) "
                                    "WHERE tr.enabled AND (( tre.item_id IN(%s) AND tre.componentcount > 0) "
                                    "OR ( tre.item_id %s AND tre.iscontainer=1 ))"
                                    "GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u "
                                    "AND sum(tre.item_id * tre.componentcount) = %u",
                                    buf2.c_str(), containers.c_str(), count, sum);
    auto results = QueryDatabase(query);
	if (!results.Success()) {
		Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe search, query: %s", query.c_str());
		Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe search, error: %s", results.ErrorMessage().c_str());
		return false;
	}

    if (results.RowCount() > 1) {
        //multiple recipes, partial match... do an extra query to get it exact.
        //this happens when combining components for a smaller recipe
        //which is completely contained within another recipe
        first = true;
        uint32 index = 0;
        buf2 = "";
        for (auto row = results.begin(); row != results.end(); ++row, ++index) {
            uint32 recipeid = (uint32)atoi(row[0]);
            if(first) {
                buf2 += StringFormat("%u", recipeid);
                first = false;
            } else
                buf2 += StringFormat(",%u", recipeid);

            //length limit on buf2
            if(index == 214) { //Maximum number of recipe matches (19 * 215 = 4096)
                Log.Out(Logs::General, Logs::Error, "GetTradeRecipe warning: Too many matches. Unable to search all recipe entries. Searched %u of %u possible entries.", index + 1, results.RowCount());
                break;
            }
        }

        query = StringFormat("SELECT tre.recipe_id "
                            "FROM tradeskill_recipe_entries AS tre "
                            "WHERE tre.recipe_id IN (%s) "
                            "GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u "
                            "AND sum(tre.item_id * tre.componentcount) = %u", buf2.c_str(), count, sum);
		results = QueryDatabase(query);
        if (!results.Success()) {
            Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, re-query: %s", query.c_str());
            Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, error: %s", results.ErrorMessage().c_str());
            return false;
        }
    }

    if (results.RowCount() < 1)
        return false;

	if(results.RowCount() > 1) {
		//The recipe is not unique, so we need to compare the container were using.
		uint32 containerId = 0;

		if(some_id) //Standard container
			containerId = some_id;
		else if(c_type)//World container
			containerId = c_type;
		else //Invalid container
			return false;

		query = StringFormat("SELECT tre.recipe_id "
                            "FROM tradeskill_recipe_entries AS tre "
                            "WHERE tre.recipe_id IN (%s) "
                            "AND tre.item_id = %u;", buf2.c_str(), containerId);
        results = QueryDatabase(query);
		if (!results.Success()) {
			Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, re-query: %s", query.c_str());
			Log.Out(Logs::General, Logs::Error, "Error in GetTradeRecipe, error: %s", results.ErrorMessage().c_str());
			return false;
		}

		if(results.RowCount() == 0) { //Recipe contents matched more than 1 recipe, but not in this container
			Log.Out(Logs::General, Logs::Error, "Combine error: Incorrect container is being used!");
			return false;
		}

		if (results.RowCount() > 1) //Recipe contents matched more than 1 recipe in this container
			Log.Out(Logs::General, Logs::Error, "Combine error: Recipe is not unique! %u matches found for container %u. Continuing with first recipe match.", results.RowCount(), containerId);

	}

	auto row = results.begin();
	uint32 recipe_id = (uint32)atoi(row[0]);

	//Right here we verify that we actually have ALL of the tradeskill components..
	//instead of part which is possible with experimentation.
	//This is here because something's up with the query above.. it needs to be rethought out
	bool has_components = true;
	query = StringFormat("SELECT item_id, componentcount "
                        "FROM tradeskill_recipe_entries "
                        "WHERE recipe_id = %i AND componentcount > 0",
                        recipe_id);
	results = QueryDatabase(query);
    if (!results.Success()) {
        return GetTradeRecipe(recipe_id, c_type, some_id, char_id, spec);
    }

	if (results.RowCount() == 0)
        return GetTradeRecipe(recipe_id, c_type, some_id, char_id, spec);

	for (auto row = results.begin(); row != results.end(); ++row) {
        int ccnt = 0;

        for(int x = MAIN_BEGIN; x < EmuConstants::MAP_WORLD_SIZE; x++) {
            const ItemInst* inst = container->GetItem(x);
            if(!inst)
                continue;

            const Item_Struct* item = GetItem(inst->GetItem()->ID);
            if (!item)
                continue;

            if(item->ID == atoi(row[0]))
                ccnt++;
        }

        if(ccnt != atoi(row[1]))
            return false;
    }

	return GetTradeRecipe(recipe_id, c_type, some_id, char_id, spec);
}
Example #12
0
ostream& operator << (ostream& os, const logstring& lstr) {
	return (os << string{begin(lstr), end(lstr)});
}
Example #13
0
 iterator end() const {
   difference_type d = thrust::distance(first, last);
   return begin() + (d/lead*rows) + (d % lead);
 }
Example #14
0
 inline const_reverse_iterator rend() const
 {
     return const_reverse_iterator(begin());
 }
Example #15
0
void CZonePlacer::placeZones(const CMapGenOptions * mapGenOptions, CRandomGenerator * rand)
{
    logGlobal->infoStream() << "Starting zone placement";

    int width = mapGenOptions->getWidth();
    int height = mapGenOptions->getHeight();

    auto zones = gen->getZones();
    bool underground = mapGenOptions->getHasTwoLevels();

    //gravity-based algorithm

    const float gravityConstant = 4e-3;
    const float stiffnessConstant = 4e-3;
    float zoneScale = 1.0f / std::sqrt(zones.size()); //zones starts small and then inflate. placing more zones is more difficult
    const float inflateModifier = 1.02;

    /*
    	let's assume we try to fit N circular zones with radius = size on a map

    	formula: sum((prescaler*n)^2)*pi = WH

    	prescaler = sqrt((WH)/(sum(n^2)*pi))
    */
    std::vector<std::pair<TRmgTemplateZoneId, CRmgTemplateZone*>> zonesVector (zones.begin(), zones.end());
    assert (zonesVector.size());

    RandomGeneratorUtil::randomShuffle(zonesVector, *rand);
    TRmgTemplateZoneId firstZone = zones.begin()->first; //we want lowest ID here
    bool undergroundFlag = false;

    std::vector<float> totalSize = { 0, 0 }; //make sure that sum of zone sizes on surface and uderground match size of the map

    const float radius = 0.4f;
    const float pi2 = 6.28f;

    for (auto zone : zonesVector)
    {
        //even distribution for surface / underground zones. Surface zones always have priority.
        int level = 0;
        if (underground) //only then consider underground zones
        {
            if (zone.first == firstZone)
            {
                level = 0;
            }
            else
            {
                level = undergroundFlag;
                undergroundFlag = !undergroundFlag; //toggle underground on/off
            }
        }

        totalSize[level] += (zone.second->getSize() * zone.second->getSize());
        float randomAngle = rand->nextDouble(0, pi2);
        zone.second->setCenter(float3(0.5f + std::sin(randomAngle) * radius, 0.5f + std::cos(randomAngle) * radius, level)); //place zones around circle
    }
    //prescale zones
    std::vector<float> prescaler = { 0, 0 };
    for (int i = 0; i < 2; i++)
        prescaler[i] = sqrt((width * height) / (totalSize[i] * 3.14f));
    float mapSize = sqrt (width * height);
    for (auto zone : zones)
    {
        zone.second->setSize (zone.second->getSize() * prescaler[zone.second->getCenter().z]);
    }

    //gravity-based algorithm. connected zones attract, intersceting zones and map boundaries push back

    //remember best solution
    float bestTotalDistance = 1e10;
    float bestTotalOverlap = 1e10;
    //float bestRatio = 1e10;
    std::map<CRmgTemplateZone *, float3> bestSolution;

    const int maxDistanceMovementRatio = zones.size() * zones.size(); //experimental - the more zones, the greater total distance expected

    auto getDistance = [](float distance) -> float
    {
        return (distance ? distance * distance : 1e-6);
    };

    std::map <CRmgTemplateZone *, float3> forces;
    std::map <CRmgTemplateZone *, float> distances;
    std::map <CRmgTemplateZone *, float> overlaps;
    while (zoneScale < 1) //until zones reach their desired size and fill the map tightly
    {
        for (auto zone : zones)
        {
            float3 forceVector(0,0,0);
            float3 pos = zone.second->getCenter();
            float totalDistance = 0;

            //attract connected zones
            for (auto con : zone.second->getConnections())
            {
                auto otherZone = zones[con];
                float3 otherZoneCenter = otherZone->getCenter();
                float distance = pos.dist2d (otherZoneCenter);
                float minDistance = (zone.second->getSize() + otherZone->getSize())/mapSize * zoneScale; //scale down to (0,1) coordinates
                if (distance > minDistance)
                {
                    //WARNING: compiler used to 'optimize' that line so it never actually worked
                    forceVector += (((otherZoneCenter - pos)*(pos.z == otherZoneCenter.z ? (minDistance/distance) : 1)/ getDistance(distance))) * gravityConstant; //positive value
                    totalDistance += (distance - minDistance);
                }
            }
            distances[zone.second] = totalDistance;

            float totalOverlap = 0;
            //separate overlaping zones
            for (auto otherZone : zones)
            {
                float3 otherZoneCenter = otherZone.second->getCenter();
                //zones on different levels don't push away
                if (zone == otherZone || pos.z != otherZoneCenter.z)
                    continue;

                float distance = pos.dist2d (otherZoneCenter);
                float minDistance = (zone.second->getSize() + otherZone.second->getSize())/mapSize * zoneScale;
                if (distance < minDistance)
                {
                    forceVector -= (((otherZoneCenter - pos)*(minDistance/(distance ? distance : 1e-3))) / getDistance(distance)) * stiffnessConstant; //negative value
                    totalOverlap += (minDistance - distance) / (zoneScale * zoneScale); //overlapping of small zones hurts us more
                }
            }

            //move zones away from boundaries
            //do not scale boundary distance - zones tend to get squashed
            float size = zone.second->getSize() / mapSize;

            auto pushAwayFromBoundary = [&forceVector, pos, &getDistance, size, stiffnessConstant, &totalOverlap](float x, float y)
            {
                float3 boundary = float3 (x, y, pos.z);
                float distance = pos.dist2d(boundary);
                totalOverlap += distance; //overlapping map boundaries is wrong as well
                forceVector -= (boundary - pos) * (size - distance) / getDistance(distance) * stiffnessConstant; //negative value
            };
            if (pos.x < size)
            {
                pushAwayFromBoundary(0, pos.y);
            }
            if (pos.x > 1-size)
            {
                pushAwayFromBoundary(1, pos.y);
            }
            if (pos.y < size)
            {
                pushAwayFromBoundary(pos.x, 0);
            }
            if (pos.y > 1-size)
            {
                pushAwayFromBoundary(pos.x, 1);
            }
            overlaps[zone.second] = totalOverlap;
            forceVector.z = 0; //operator - doesn't preserve z coordinate :/
            forces[zone.second] = forceVector;
        }
        //update positions
        for (auto zone : forces)
        {
            zone.first->setCenter (zone.first->getCenter() + zone.second);
        }

        //now perform drastic movement of zone that is completely not linked
        float maxRatio = 0;
        CRmgTemplateZone * misplacedZone = nullptr;

        float totalDistance = 0;
        float totalOverlap = 0;
        for (auto zone : distances) //find most misplaced zone
        {
            totalDistance += zone.second;
            float overlap = overlaps[zone.first];
            totalOverlap += overlap;
            float ratio = (zone.second + overlap) / forces[zone.first].mag(); //if distance to actual movement is long, the zone is misplaced
            if (ratio > maxRatio)
            {
                maxRatio = ratio;
                misplacedZone = zone.first;
            }
        }
        logGlobal->traceStream() << boost::format("Total distance between zones in this iteration: %2.4f, Total overlap: %2.4f, Worst misplacement/movement ratio: %3.2f") % totalDistance % totalOverlap % maxRatio;

        //save best solution before drastic jump
        if (totalDistance + totalOverlap < bestTotalDistance + bestTotalOverlap)
        {
            bestTotalDistance = totalDistance;
            bestTotalOverlap = totalOverlap;
            //if (maxRatio < bestRatio)
            //{
            //	bestRatio = maxRatio;
            for (auto zone : zones)
                bestSolution[zone.second] = zone.second->getCenter();
        }

        if (maxRatio > maxDistanceMovementRatio)
        {
            CRmgTemplateZone * targetZone = nullptr;
            float3 ourCenter = misplacedZone->getCenter();

            if (totalDistance > totalOverlap)
            {
                //find most distant zone that should be attracted and move inside it
                float maxDistance = 0;
                for (auto con : misplacedZone->getConnections())
                {
                    auto otherZone = zones[con];
                    float distance = otherZone->getCenter().dist2dSQ(ourCenter);
                    if (distance > maxDistance)
                    {
                        maxDistance = distance;
                        targetZone = otherZone;
                    }
                }
                float3 vec = targetZone->getCenter() - ourCenter;
                float newDistanceBetweenZones = (std::max(misplacedZone->getSize(), targetZone->getSize())) * zoneScale / mapSize;
                logGlobal->traceStream() << boost::format("Trying to move zone %d %s towards %d %s. Old distance %f") %
                                         misplacedZone->getId() % ourCenter() % targetZone->getId() % targetZone->getCenter()() % maxDistance;
                logGlobal->traceStream() << boost::format("direction is %s") % vec();

                misplacedZone->setCenter(targetZone->getCenter() - vec.unitVector() * newDistanceBetweenZones); //zones should now overlap by half size
                logGlobal->traceStream() << boost::format("New distance %f") % targetZone->getCenter().dist2d(misplacedZone->getCenter());
            }
            else
            {
                float maxOverlap = 0;
                for (auto otherZone : zones)
                {
                    float3 otherZoneCenter = otherZone.second->getCenter();

                    if (otherZone.second == misplacedZone || otherZoneCenter.z != ourCenter.z)
                        continue;

                    float distance = otherZoneCenter.dist2dSQ(ourCenter);
                    if (distance > maxOverlap)
                    {
                        maxOverlap = distance;
                        targetZone = otherZone.second;
                    }
                }
                float3 vec = ourCenter - targetZone->getCenter();
                float newDistanceBetweenZones = (misplacedZone->getSize() + targetZone->getSize()) * zoneScale / mapSize;
                logGlobal->traceStream() << boost::format("Trying to move zone %d %s away from %d %s. Old distance %f") %
                                         misplacedZone->getId() % ourCenter() % targetZone->getId() % targetZone->getCenter()() % maxOverlap;
                logGlobal->traceStream() << boost::format("direction is %s") % vec();

                misplacedZone->setCenter(targetZone->getCenter() + vec.unitVector() * newDistanceBetweenZones); //zones should now be just separated
                logGlobal->traceStream() << boost::format("New distance %f") % targetZone->getCenter().dist2d(misplacedZone->getCenter());
            }
        }

        zoneScale *= inflateModifier; //increase size of zones so they
    }

    logGlobal->traceStream() << boost::format("Best fitness reached: total distance %2.4f, total overlap %2.4f") % bestTotalDistance % bestTotalOverlap;
    for (auto zone : zones) //finalize zone positions
    {
        zone.second->setPos (cords (bestSolution[zone.second]));
        logGlobal->traceStream() << boost::format ("Placed zone %d at relative position %s and coordinates %s") % zone.first % zone.second->getCenter() % zone.second->getPos();
    }
}
Example #16
0
void Client::SendTradeskillDetails(uint32 recipe_id) {

    //pull the list of components
	std::string query = StringFormat("SELECT tre.item_id,tre.componentcount,i.icon,i.Name "
                                    "FROM tradeskill_recipe_entries AS tre "
                                    "LEFT JOIN items AS i ON tre.item_id = i.id "
                                    "WHERE tre.componentcount > 0 AND tre.recipe_id = %u",
                                    recipe_id);
    auto results = database.QueryDatabase(query);
	if (!results.Success()) {
		return;
	}

	if(results.RowCount() < 1) {
		Log.Out(Logs::General, Logs::Error, "Error in SendTradeskillDetails: no components returned");
		return;
	}

	if(results.RowCount() > 10) {
		Log.Out(Logs::General, Logs::Error, "Error in SendTradeskillDetails: too many components returned (%u)", results.RowCount());
		return;
	}

	//biggest this packet can ever be:
	// 64 * 10 + 8 * 10 + 4 + 4 * 10 = 764
	char *buf = new char[775];	//dynamic so we can just give it to EQApplicationPacket
	uint8 r,k;

	uint32 *header = (uint32 *) buf;
	//Hell if I know why this is in the wrong byte order....
	*header = htonl(recipe_id);

	char *startblock = buf;
	startblock += sizeof(uint32);

	uint32 *ffff_start = (uint32 *) startblock;
	//fill in the FFFF's as if there were 0 items
	for(r = 0; r < 10; r++) { // world:item container size related?
		*ffff_start = 0xFFFFFFFF;
		ffff_start++;
	}
	char * datastart = (char *) ffff_start;
	char * cblock = (char *) ffff_start;

	uint32 *itemptr;
	uint32 *iconptr;
	uint32 len;
	uint32 datalen = 0;
	uint8 count = 0;

	for(auto row = results.begin(); row != results.end(); ++row) {

		//watch for references to items which are not in the
		//items table, which the left join will make nullptr...
		if(row[2] == nullptr || row[3] == nullptr)
			continue;

		uint32 item = (uint32)atoi(row[0]);
		uint8 num = (uint8) atoi(row[1]);
		uint32 icon = (uint32) atoi(row[2]);

		const char *name = row[3];
		len = strlen(name);
		if(len > 63)
			len = 63;

		//Hell if I know why these are in the wrong byte order....
		item = htonl(item);
		icon = htonl(icon);

		//if we get more than 10 items, just start skipping them...
		for(k = 0; k < num && count < 10; k++) { // world:item container size related?
			itemptr = (uint32 *) cblock;
			cblock += sizeof(uint32);
			datalen += sizeof(uint32);
			iconptr = (uint32 *) cblock;
			cblock += sizeof(uint32);
			datalen += sizeof(uint32);

			*itemptr = item;
			*iconptr = icon;
			strncpy(cblock, name, len);

			cblock[len] = '\0';	//just making sure.
			cblock += len + 1;	//get the null
			datalen += len + 1;	//get the null
			count++;
		}

	}

	//now move the item data over top of the FFFFs
	uint8 dist = sizeof(uint32) * (10 - count);
	startblock += dist;
	memmove(startblock, datastart, datalen);

	uint32 total = sizeof(uint32) + dist + datalen;

	EQApplicationPacket* outapp = new EQApplicationPacket(OP_RecipeDetails);
	outapp->size = total;
	outapp->pBuffer = (uchar*) buf;
	QueuePacket(outapp);
	DumpPacket(outapp);
	safe_delete(outapp);
}
Example #17
0
void Fleet::MovementPhase() {
    //Logger().debugStream() << "Fleet::MovementPhase this: " << this->Name() << " id: " << this->ID();

    m_arrived_this_turn = false;
    m_arrival_starlane = UniverseObject::INVALID_OBJECT_ID;

    int prev_prev_system = m_prev_system;

    Empire* empire = Empires().Lookup(this->Owner());

    // if owner of fleet can resupply ships at the location of this fleet, then
    // resupply all ships in this fleet
    if (empire && empire->FleetOrResourceSupplyableAtSystem(this->SystemID()))
        for (Fleet::const_iterator ship_it = this->begin(); ship_it != this->end(); ++ship_it)
            if (Ship* ship = GetObject<Ship>(*ship_it))
                ship->Resupply();


    System* current_system = GetObject<System>(SystemID());
    System* const initial_system = current_system;
    std::list<MovePathNode> move_path = this->MovePath();
    std::list<MovePathNode>::const_iterator it = move_path.begin();
    std::list<MovePathNode>::const_iterator next_it = it;
    if (next_it != move_path.end())
        ++next_it;


    // is the ship stuck in a system for a whole turn?
    if (current_system) {
        // in a system.  if there is no system after the current one in the
        // path, or the current and next nodes have the same system id, that
        // is an actual system, then won't be moving this turn.
        if ((next_it == move_path.end()) ||
            (it->object_id != INVALID_OBJECT_ID && it->object_id == next_it->object_id)
           )
        {
            // fuel regeneration for ships in stationary fleet
            if (this->FinalDestinationID() == UniverseObject::INVALID_OBJECT_ID ||
                this->FinalDestinationID() == this->SystemID())
            {
                for (Fleet::const_iterator ship_it = this->begin(); ship_it != this->end(); ++ship_it) {
                    if (Ship* ship = GetObject<Ship>(*ship_it))
                        if (Meter* fuel_meter = ship->UniverseObject::GetMeter(METER_FUEL)) {
                            fuel_meter->AddToCurrent(0.1001);
                            fuel_meter->BackPropegate();
                        }
                }
            }
            return;
        }
    }


    // if fleet not moving, nothing more to do.
    if (move_path.empty() || move_path.size() == 1) {
        //Logger().debugStream() << "Fleet::MovementPhase: Fleet move path is empty or has only one entry.  doing nothing";
        return;
    }

    //Logger().debugStream() << "Fleet::MovementPhase move path:";
    //for (std::list<MovePathNode>::const_iterator it = move_path.begin(); it != move_path.end(); ++it)
    //    Logger().debugStream() << "... (" << it->x << ", " << it->y << ") at object id: " << it->object_id << " eta: " << it->eta << (it->turn_end ? " (end of turn)" : " (during turn)");


    // move fleet in sequence to MovePathNodes it can reach this turn
    double fuel_consumed = 0.0;
    for (it = move_path.begin(); it != move_path.end(); ++it) {
        next_it = it;   ++next_it;

        System* system = GetObject<System>(it->object_id);

        //Logger().debugStream() << "... node " << (system ? system->Name() : "no system");

        // is this system the last node reached this turn?  either it's an end of turn node,
        // or there are no more nodes after this one on path
        bool node_is_next_stop = (it->turn_end || next_it == move_path.end());


        if (system) {
            // node is a system.  explore system for all owners of this fleet
            if (empire)
                empire->AddExploredSystem(it->object_id);

            prev_prev_system = m_prev_system;
            m_prev_system = system->ID();               // passing a system, so update previous system of this fleet

            bool resupply_here = empire ? empire->FleetOrResourceSupplyableAtSystem(system->ID()) : false;

            // if this system can provide supplies, reset consumed fuel and refuel ships
            if (resupply_here) {
                //Logger().debugStream() << " ... node has fuel supply.  consumed fuel for movement reset to 0 and fleet resupplied";
                fuel_consumed = 0.0;
                for (Fleet::const_iterator ship_it = this->begin(); ship_it != this->end(); ++ship_it) {
                    Ship* ship = GetObject<Ship>(*ship_it);
                    assert(ship);
                    ship->Resupply();
                }
            }


            if (node_is_next_stop) {                    // is system the last node reached this turn?
                system->Insert(this);                       // fleet ends turn at this node.  insert fleet into system
                current_system = system;
                //Logger().debugStream() << "... ... inserted fleet into system";
                break;
            } else {
                // fleet will continue past this system this turn.
                //Logger().debugStream() << "... ... moved fleet to system (not inserted)";
                if (!resupply_here) {
                    fuel_consumed += 1.0;
                    //Logger().debugStream() << "... ... consuming 1 unit of fuel to continue moving.  total fuel consumed now: " << fuel_consumed;
                } else {
                    //Logger().debugStream() << "... ... not consuming fuel to depart resupply system";
                }
            }

        } else {
            // node is not a system.
            if (node_is_next_stop) {                    // node is not a system, but is it the last node reached this turn?
                MoveTo(it->x, it->y);                       // fleet ends turn at this node.  move fleet here
                //Logger().debugStream() << "... ... moved fleet to position";
                break;
            }
        }
    }


    //Logger().debugStream() << "Fleet::MovementPhase rest of move path:";
    //for (std::list<MovePathNode>::const_iterator it2 = it; it2 != move_path.end(); ++it2)
    //    Logger().debugStream() << "... (" << it2->x << ", " << it2->y << ") at object id: " << it2->object_id << " eta: " << it2->eta << (it2->turn_end ? " (end of turn)" : " (during turn)");

    // update next system
    if (m_moving_to != SystemID() && next_it != move_path.end() && it != move_path.end()) {
        // there is another system later on the path to aim for.  find it
        for (; next_it != move_path.end(); ++next_it) {
            if (GetObject<System>(next_it->object_id)) {
                //Logger().debugStream() << "___ setting m_next_system to " << next_it->object_id;
                m_next_system = next_it->object_id;
                break;
            }
        }

    } else {
        // no more systems on path
        m_arrived_this_turn = current_system != initial_system;
        m_arrival_starlane = prev_prev_system;
        m_moving_to = m_next_system = m_prev_system = UniverseObject::INVALID_OBJECT_ID;
    }


    // consume fuel from ships in fleet
    if (fuel_consumed > 0.0) {
        for (const_iterator ship_it = begin(); ship_it != end(); ++ship_it)
            if (Ship* ship = GetObject<Ship>(*ship_it))
                if (Meter* meter = ship->UniverseObject::GetMeter(METER_FUEL)) {
                    meter->AddToCurrent(-fuel_consumed);
                    meter->BackPropegate();
                }
    }
}
bool VACVariable::averaging()
{
    Cost Top = wcsp->getUb();
    bool change = false;
    EnumeratedVariable* x;
    EnumeratedVariable* y;
    Constraint* ctr = NULL;
    ConstraintList::iterator itc = getConstrs()->begin();
    if (itc != getConstrs()->end())
        ctr = (*itc).constr;
    while (ctr) {
        if (ctr->isBinary() && !ctr->isSep()) {
            BinaryConstraint* bctr = (BinaryConstraint*)ctr;
            x = (EnumeratedVariable*)bctr->getVarDiffFrom((Variable*)this);
            for (iterator it = begin(); it != end(); ++it) {
                Cost cu = getCost(*it);
                Cost cmin = Top;
                for (iterator itx = x->begin(); itx != x->end(); ++itx) {
                    Cost cbin = bctr->getCost(this, x, *it, *itx);
                    if (cbin < cmin)
                        cmin = cbin;
                }
                assert(cmin < Top);
                Double mean = to_double(cmin + cu) / 2.;
                Double extc = to_double(cu) - mean;
                if (abs(extc) >= 1) {
                    Cost costi = (Long)extc;
                    for (iterator itx = x->begin(); itx != x->end(); ++itx) {
                        bctr->addcost(this, x, *it, *itx, costi);
                    }
                    if (mean > to_double(cu))
                        project(*it, -costi);
                    else
                        extend(*it, costi);
                    change = true;
                }
            }
        } else if (ctr->isTernary() && !ctr->isSep()) {
            TernaryConstraint* tctr = (TernaryConstraint*)ctr;
            x = (EnumeratedVariable*)tctr->getVar(0);
            if (x == this)
                x = (EnumeratedVariable*)tctr->getVar(1);
            y = (EnumeratedVariable*)tctr->getVarDiffFrom((Variable*)this, (Variable*)x);
            for (iterator it = begin(); it != end(); ++it) {
                Cost cu = getCost(*it);
                Cost cmin = Top;
                for (iterator itx = x->begin(); itx != x->end(); ++itx) {
                    for (iterator ity = y->begin(); ity != y->end(); ++ity) {
                        Cost ctern = tctr->getCost(this, x, y, *it, *itx, *ity);
                        if (ctern < cmin)
                            cmin = ctern;
                    }
                }
                assert(cmin < Top);
                Double mean = to_double(cmin + cu) / 2.;
                Double extc = to_double(cu) - mean;
                if (abs(extc) >= 1) {
                    Cost costi = (Long)extc;
                    for (iterator itx = x->begin(); itx != x->end(); ++itx) {
                        for (iterator ity = y->begin(); ity != y->end(); ++ity) {
                            tctr->addCost(this, x, y, *it, *itx, *ity, costi);
                        }
                    }
                    if (mean > to_double(cu))
                        project(*it, -costi);
                    else
                        extend(*it, costi);
                    change = true;
                }
            }
        } else if (ctr->isNary() && !ctr->isSep()) {
            NaryConstraint* nctr = (NaryConstraint*)ctr;
            for (iterator it = begin(); it != end(); ++it) {
                Cost cu = getCost(*it);
                Cost cmin = Top;
                int tindex = nctr->getIndex(this);
                String tuple;
                Cost cost;
                Long nbtuples = 0;
                nctr->first();
                while (nctr->next(tuple, cost)) {
                    nbtuples++;
                    if (toValue(tuple[tindex] - CHAR_FIRST) == (*it) && cost < cmin)
                        cmin = cost;
                }
                if (nctr->getDefCost() < cmin && nbtuples < nctr->getDomainSizeProduct() / getDomainSize())
                    cmin = nctr->getDefCost();
                //				assert(cmin < Top);
                Double mean = to_double(cmin + cu) / 2.;
                Double extc = to_double(cu) - mean;
                if (abs(extc) >= 1) {
                    Cost costi = (Cost)extc;
                    nctr->addtoTuples(this, *it, costi);
                    if (mean > to_double(cu))
                        project(*it, -costi);
                    else
                        extend(*it, costi);
                    change = true;
                }
            }
        }
        ++itc;
        if (itc != getConstrs()->end())
            ctr = (*itc).constr;
        else
            ctr = NULL;
    }
    return change;
}
int main(int argc, char** argv) {
	std::cout << "hello world" << std::endl;

	std::random_device rand{};

	auto input_dim = 2u;
	auto output_dim = 1u;
	auto batch_size = 4u;

	std::vector<neu::cpu_vector> cpu_input = {
		{0.f, 0.f}, {1.f, 0.f}, {0.f, 1.f}, {1.f, 1.f}
	};
	std::vector<neu::cpu_vector> cpu_teach = {
		{0.f}, {1.f}, {1.f}, {0.f}
	};

	neu::gpu_vector input;
	for(auto const& cpui : cpu_input) {
		input.insert(input.end(), cpui.begin(), cpui.end());
	}
	neu::gpu_vector teach;
	for(auto const& cput : cpu_teach) {
		teach.insert(teach.end(), cput.begin(), cput.end());
	}

	auto layers = std::make_tuple(
		neu::make_full_connected_layer(input_dim, 3, batch_size, neu::rectifier(),
			neu::adagrad(input_dim*3, 3, 0.1f)),
		neu::make_full_connected_layer(3, output_dim, batch_size, neu::sigmoid(),
			neu::adagrad(3*output_dim, output_dim, 0.1f))
	);

	std::uniform_real_distribution<> bin{-1.f,1.f};
	neu::tuple_foreach(layers, [&rand, &bin](auto& l){
		l.init_weight_randomly([&rand, &bin]() { return bin(rand); }); });
	for(auto i = 0u; i < 1000u; ++i) {
		neu::feedforward_x(layers, input);

		const auto y = neu::layer_get_y(neu::tuple_back(layers));
		neu::gpu_vector errors(y.size());
		boost::compute::transform(y.begin(), y.end(), teach.begin(), errors.begin(),
			boost::compute::minus<neu::scalar>());
		neu::feedback_delta(layers, errors);

		neu::update_delta_weight(layers, input);
		neu::update_weight(layers);

		neu::gpu_vector squared_errors(errors.size());
		boost::compute::transform(errors.begin(), errors.end(),
			errors.begin(), squared_errors.begin(),
			boost::compute::multiplies<neu::scalar>());
		auto error_sum = boost::compute::accumulate(
			squared_errors.begin(), squared_errors.end(), 0.0f);
		if(i%100 == 0) {
			std::cout << i << ":" << error_sum << std::endl;
		}
	}
	neu::print(teach); std::cout << "\n";
	auto y = std::get<std::tuple_size<decltype(layers)>::value-1>(layers).get_y();
	neu::print(y);
	std::cout << std::endl;
}
void CPUUncontrolledApproximation::perform() {
    const auto &ctx = kernel->context();
    auto &stateModel = kernel->getCPUKernelStateModel();
    auto nl = stateModel.getNeighborList();
    auto &data = nl->data();
    const auto &box = ctx.boxSize().data();
    const auto &pbc = ctx.periodicBoundaryConditions().data();

    if (ctx.recordReactionsWithPositions()) {
        kernel->getCPUKernelStateModel().reactionRecords().clear();
    }
    if (ctx.recordReactionCounts()) {
        stateModel.resetReactionCounts();
    }

    // gather events
    std::vector<std::promise<std::size_t>> n_events_promises(kernel->getNThreads());
    std::vector<event_promise_t> promises(kernel->getNThreads());
    {

        auto &pool = kernel->pool();

        std::vector<std::function<void(std::size_t)>> executables;
        executables.reserve(kernel->getNThreads());

        std::size_t grainSize = data.size() / kernel->getNThreads();
        std::size_t nlGrainSize = nl->nCells() / kernel->getNThreads();

        auto it = data.cbegin();
        std::size_t it_nl = 0;
        for (auto i = 0U; i < kernel->getNThreads()-1 ; ++i) {
            auto itNext = std::min(it+grainSize, data.cend());

            auto nlNext = std::min(it_nl + nlGrainSize, nl->nCells());
            auto bounds_nl = std::make_tuple(it_nl, nlNext);

            pool.push(findEvents, it, itNext, bounds_nl, kernel, timeStep(), false, std::cref(*nl),
                      std::ref(promises.at(i)), std::ref(n_events_promises.at(i)));

            it = itNext;
            it_nl = nlNext;
        }
        pool.push(findEvents, it, data.cend(), std::make_tuple(it_nl, nl->nCells()), kernel, timeStep(), false,
                  std::cref(*nl), std::ref(promises.back()), std::ref(n_events_promises.back()));
    }

    // collect events
    std::vector<event_t> events;
    {
        std::size_t n_events = 0;
        for (auto &&f : n_events_promises) {
            n_events += f.get_future().get();
        }
        events.reserve(n_events);
        for (auto &&f : promises) {
            auto eventUpdate = std::move(f.get_future().get());
            auto mBegin = std::make_move_iterator(eventUpdate.begin());
            auto mEnd = std::make_move_iterator(eventUpdate.end());
            events.insert(events.end(), mBegin, mEnd);
        }
    }

    // shuffle reactions
    std::shuffle(events.begin(), events.end(), std::mt19937(std::random_device()()));

    // execute reactions
    {
        data_t::EntriesUpdate newParticles{};
        std::vector<data_t::size_type> decayedEntries{};

        // todo better conflict detection?
        for (auto it = events.begin(); it != events.end(); ++it) {
            auto &event = *it;
            if (event.cumulativeRate == 0) {
                auto entry1 = event.idx1;
                if (event.nEducts == 1) {
                    auto reaction = ctx.reactions().order1ByType(event.t1)[event.reactionIndex];
                    if (ctx.recordReactionsWithPositions()) {
                        record_t record;
                        record.id = reaction->id();
                        performReaction(&data, ctx, entry1, entry1, newParticles, decayedEntries, reaction, &record);
                        bcs::fixPosition(record.where, box, pbc);
                        kernel->getCPUKernelStateModel().reactionRecords().push_back(record);
                    } else {
                        performReaction(&data, ctx, entry1, entry1, newParticles, decayedEntries, reaction, nullptr);
                    }
                    if (ctx.recordReactionCounts()) {
                        auto &counts = stateModel.reactionCounts();
                        counts.at(reaction->id())++;
                    }
                    for (auto _it2 = it + 1; _it2 != events.end(); ++_it2) {
                        if (_it2->idx1 == entry1 || _it2->idx2 == entry1) {
                            _it2->cumulativeRate = 1;
                        }
                    }
                } else {
                    auto reaction = ctx.reactions().order2ByType(event.t1, event.t2)[event.reactionIndex];
                    if (ctx.recordReactionsWithPositions()) {
                        record_t record;
                        record.id = reaction->id();
                        performReaction(&data, ctx, entry1, event.idx2, newParticles, decayedEntries, reaction, &record);
                        bcs::fixPosition(record.where, box, pbc);
                        kernel->getCPUKernelStateModel().reactionRecords().push_back(record);
                    } else {
                        performReaction(&data, ctx, entry1, event.idx2, newParticles, decayedEntries, reaction, nullptr);
                    }
                    if (ctx.recordReactionCounts()) {
                        auto &counts = stateModel.reactionCounts();
                        counts.at(reaction->id())++;
                    }
                    for (auto _it2 = it + 1; _it2 != events.end(); ++_it2) {
                        if (_it2->idx1 == entry1 || _it2->idx2 == entry1 ||
                            _it2->idx1 == event.idx2 || _it2->idx2 == event.idx2) {
                            _it2->cumulativeRate = 1;
                        }
                    }
                }
            }
        }
        data.update(std::make_pair(std::move(newParticles), std::move(decayedEntries)));
    }
}
bool RAS_MeshSlot::Join(RAS_MeshSlot *target, MT_Scalar distance)
{
	RAS_DisplayArrayList::iterator it;
	iterator mit;
	size_t i;

	// verify if we can join
	if (m_joinSlot || (m_joinedSlots.empty() == false) || target->m_joinSlot)
		return false;

	if (!Equals(target))
		return false;
	
	MT_Vector3 co(&m_OpenGLMatrix[12]);
	MT_Vector3 targetco(&target->m_OpenGLMatrix[12]);

	if ((co - targetco).length() > distance)
		return false;

	MT_Matrix4x4 mat(m_OpenGLMatrix);
	MT_Matrix4x4 targetmat(target->m_OpenGLMatrix);
	targetmat.invert();

	MT_Matrix4x4 transform = targetmat*mat;
	
	// m_mesh, clientobj
	m_joinSlot = target;
	m_joinInvTransform = transform;
	m_joinInvTransform.invert();
	target->m_joinedSlots.push_back(this);

	MT_Matrix4x4 ntransform = m_joinInvTransform.transposed();
	ntransform[0][3] = ntransform[1][3] = ntransform[2][3] = 0.0f;

	for (begin(mit); !end(mit); next(mit))
		for (i=mit.startvertex; i<mit.endvertex; i++)
			mit.vertex[i].Transform(transform, ntransform);
	
	/* We know we'll need a list at least this big, reserve in advance */
	target->m_displayArrays.reserve(target->m_displayArrays.size() + m_displayArrays.size());

	for (it=m_displayArrays.begin(); it!=m_displayArrays.end(); it++) {
		target->m_displayArrays.push_back(*it);
		target->m_endarray++;
		target->m_endvertex = target->m_displayArrays.back()->m_vertex.size();
		target->m_endindex = target->m_displayArrays.back()->m_index.size();
	}

	if (m_DisplayList) {
		m_DisplayList->Release();
		m_DisplayList = NULL;
	}
	if (target->m_DisplayList) {
		target->m_DisplayList->Release();
		target->m_DisplayList = NULL;
	}
	
	return true;
#if 0
	return false;
#endif
}
boolean CREST::begin(const char* host)
{
  return begin(host, 80, false);
}
Example #23
0
ViewElementList::~ViewElementList()
{
    for (iterator i = begin(); i != end(); ++i) {
        delete (*i);
    }
}
Example #24
0
void StubCodeDesc::print_on(outputStream* st) const {
  st->print(group());
  st->print("::");
  st->print(name());
  st->print(" [" INTPTR_FORMAT ", " INTPTR_FORMAT "[ (%d bytes)", begin(), end(), size_in_bytes());
}
Example #25
0
int C4GraphCollection::GetSeriesCount() const {
  int iCount = 0;
  for (const_iterator i = begin(); i != end(); ++i)
    iCount += (*i)->GetSeriesCount();
  return iCount;
}
Example #26
0
 range_safe_iterator_t<Rng> operator()(Rng &&rng, V const &val, P proj = P{}) const
 {
     return (*this)(begin(rng), end(rng), val, std::move(proj));
 }
Example #27
0
void C4GraphCollection::SetAverageTime(int iToTime) {
  if (iCommonAvgTime = iToTime)
    for (iterator i = begin(); i != end(); ++i) (*i)->SetAverageTime(iToTime);
}
Example #28
0
        typedef rx::resource<std::vector<int>> resource;

        WHEN("created by scope"){

            auto res = w.start(
                [&]() {
                    return rx::observable<>::
                        scope(
                            [&](){
                                return resource(rxu::to_vector({1, 2, 3, 4, 5}));
                            },
                            [&](resource r){
                                auto msg = std::vector<rxsc::test::messages<int>::recorded_type>();
                                int time = 10;
                                auto values = r.get();
                                std::for_each(values.begin(), values.end(), [&](int &v){
                                    msg.push_back(on.next(time, v));
                                    time += 10;
                                });
                                msg.push_back(on.completed(time));
                                xs.reset(sc.make_cold_observable(msg));
                                return xs.get();
                            }
                        )
                        // forget type to workaround lambda deduction bug on msvc 2013
                        .as_dynamic();
                }
            );

            THEN("the output stops on completion"){
                auto required = rxu::to_vector({
Example #29
0
LambdaDataReaderListener<TempSensorType> listener;

listener.data_available = [](DataReader<TempSensorType>& dr) { 
  auto samples = dr.read();
  std::for_each(samples.begin(), samples.end(),
		[](const Sample<TempSensorType>& s) { 
		  std::cout << s.data() << std::endl;
		});
  
};

dr.listener(&listener, StatusMask::data_available());
Example #30
0
 inline const_iterator cbegin() const
 {
     return begin();
 }