void PhraseTableCreator::EncodeTargetPhrasePREnc(std::vector<std::string>& s,
std::vector<std::string>& t,
std::set<AlignPoint>& a,
size_t ownRank,
std::ostream& os)
{
std::vector<unsigned> encodedSymbols(t.size());
std::vector<unsigned> encodedSymbolsLengths(t.size(), 0);
ConsistentPhrases cp(s.size(), t.size(), a);
while(!cp.Empty()) {
ConsistentPhrases::Phrase p = cp.Pop();
std::stringstream key1;
key1 << s[p.i];
for(int i = p.i+1; i < p.i+p.m; i++)
key1 << " " << s[i];
std::stringstream key2;
key2 << t[p.j];
for(int i = p.j+1; i < p.j+p.n; i++)
key2 << " " << t[i];
int rank = -1;
std::string key1Str = key1.str(), key2Str = key2.str();
size_t idx = m_rnkHash[MakeSourceTargetKey(key1Str, key2Str)];
if(idx != m_rnkHash.GetSize())
rank = m_ranks[idx];
if(rank >= 0 && (m_maxRank == 0 || unsigned(rank) < m_maxRank)) {
if(unsigned(p.m) != s.size() || unsigned(rank) < ownRank) {
std::stringstream encodedSymbol;
encodedSymbols[p.j] = EncodePREncSymbol2(p.i-p.j, s.size()-(p.i+p.m), rank);
encodedSymbolsLengths[p.j] = p.n;
std::set<AlignPoint> tAlignment;
for(std::set<AlignPoint>::iterator it = a.begin();
it != a.end(); it++)
if(it->first < p.i || it->first >= p.i + p.m
|| it->second < p.j || it->second >= p.j + p.n)
tAlignment.insert(*it);
a = tAlignment;
cp.RemoveOverlap(p);
}
}
}
std::stringstream encodedTargetPhrase;
size_t j = 0;
while(j < t.size()) {
if(encodedSymbolsLengths[j] > 0) {
unsigned encodedSymbol = encodedSymbols[j];
m_symbolCounter.Increase(encodedSymbol);
os.write((char*)&encodedSymbol, sizeof(encodedSymbol));
j += encodedSymbolsLengths[j];
} else {
unsigned targetSymbolId = GetOrAddTargetSymbolId(t[j]);
unsigned encodedSymbol = EncodePREncSymbol1(targetSymbolId);
m_symbolCounter.Increase(encodedSymbol);
os.write((char*)&encodedSymbol, sizeof(encodedSymbol));
j++;
}
}
unsigned stopSymbolId = GetTargetSymbolId(m_phraseStopSymbol);
unsigned encodedSymbol = EncodePREncSymbol1(stopSymbolId);
os.write((char*)&encodedSymbol, sizeof(encodedSymbol));
m_symbolCounter.Increase(encodedSymbol);
}
void Task::schedule()
{
// Is waiting for execution
// Increment active task count before spawning.
Kokkos::atomic_increment( m_active_count );
// spawn in qthread. must malloc the precondition array and give to qthread.
// qthread will eventually free this allocation so memory will not be leaked.
// concern with thread safety of malloc, does this need to be guarded?
aligned_t ** qprecon = (aligned_t **) malloc( ( m_dep_size + 1 ) * sizeof(aligned_t *) );
qprecon[0] = reinterpret_cast<aligned_t *>( uintptr_t(m_dep_size) );
for ( int i = 0 ; i < m_dep_size ; ++i ) {
qprecon[i+1] = & m_dep[i]->m_qfeb ; // Qthread precondition flag
}
if ( m_apply_team && ! m_apply_single ) {
// If more than one shepherd spawn on a shepherd other than this shepherd
const int num_shepherd = qthread_num_shepherds();
const int num_worker_per_shepherd = qthread_num_workers_local(NO_SHEPHERD);
const int this_shepherd = qthread_shep();
int spawn_shepherd = ( this_shepherd + 1 ) % num_shepherd ;
#if 0
fprintf( stdout
, "worker(%d.%d) task 0x%.12lx spawning on shepherd(%d) clone(%d)\n"
, qthread_shep()
, qthread_worker_local(NULL)
, reinterpret_cast<unsigned long>(this)
, spawn_shepherd
, num_worker_per_shepherd - 1
);
fflush(stdout);
#endif
qthread_spawn_cloneable
( & Task::qthread_func
, this
, 0
, NULL
, m_dep_size , qprecon /* dependences */
, spawn_shepherd
, unsigned( QTHREAD_SPAWN_SIMPLE | QTHREAD_SPAWN_LOCAL_PRIORITY )
, num_worker_per_shepherd - 1
);
}
else {
qthread_spawn( & Task::qthread_func /* function */
, this /* function argument */
, 0
, NULL
, m_dep_size , qprecon /* dependences */
, NO_SHEPHERD
, QTHREAD_SPAWN_SIMPLE /* allows optimization for non-blocking task */
);
}
}
void CCommandProcessor::DisplayCpuLoad ( void )
{
const uint8_t * lastMinute;
uint8_t lastMinuteIndex;
const uint8_t * lastSecond;
uint8_t lastSecondIndex;
GetCpuLoadStats( &lastMinute, &lastMinuteIndex,
&lastSecond, &lastSecondIndex );
uint32_t minuteAverage = 0;
for ( unsigned j = 0; j < CPU_LOAD_LONG_PERIOD_SLOT_COUNT; ++j )
{
const unsigned index = ( lastMinuteIndex + j ) % CPU_LOAD_LONG_PERIOD_SLOT_COUNT;
minuteAverage += lastMinute[ index ];
}
minuteAverage = minuteAverage * 100 / ( CPU_LOAD_LONG_PERIOD_SLOT_COUNT * 255 );
assert( minuteAverage <= 100 );
PrintStr( "CPU load in the last 60 seconds (1 second intervals, oldest to newest):" EOL );
for ( unsigned j = 0; j < CPU_LOAD_LONG_PERIOD_SLOT_COUNT; ++j )
{
const unsigned index = ( lastMinuteIndex + j ) % CPU_LOAD_LONG_PERIOD_SLOT_COUNT;
const uint32_t val = lastMinute[ index ] * 100 / 255;
assert( val <= 100 );
Printf( "%3u %%" EOL, unsigned( val ) );
}
uint32_t secondAverage = 0;
for ( unsigned j = 0; j < CPU_LOAD_SHORT_PERIOD_SLOT_COUNT; ++j )
{
const unsigned index = ( lastSecondIndex + j ) % CPU_LOAD_SHORT_PERIOD_SLOT_COUNT;
secondAverage += lastSecond[ index ];
}
secondAverage = secondAverage * 100 / ( CPU_LOAD_SHORT_PERIOD_SLOT_COUNT * 255 );
assert( secondAverage <= 100 );
PrintStr( "CPU load in the last second (50 ms intervals, oldest to newest):" EOL );
for ( unsigned j = 0; j < CPU_LOAD_SHORT_PERIOD_SLOT_COUNT; ++j )
{
const unsigned index = ( lastSecondIndex + j ) % CPU_LOAD_SHORT_PERIOD_SLOT_COUNT;
const uint32_t val = lastSecond[ index ] * 100 / 255;
assert( val <= 100 );
Printf( "%2u %%" EOL, unsigned( val ) );
}
Printf( "Average CPU load in the last 60 seconds: %2u %%" EOL, unsigned( minuteAverage ) );
Printf( "Average CPU load in the last second : %2u %%" EOL, unsigned( secondAverage ) );
}
CstrBuffer::CstrBuffer(char* data, int len)
: m_buffer(data), m_len(len), m_cap(len) {
assert(unsigned(len) < kMaxCap);
}
*b = bb & (bb - 1);
return BSFTable[bsf_index(bb)];
}
Square msb(Bitboard b) {
unsigned b32;
int result = 0;
if (b > 0xFFFFFFFF)
{
b >>= 32;
result = 32;
}
b32 = unsigned(b);
if (b32 > 0xFFFF)
{
b32 >>= 16;
result += 16;
}
if (b32 > 0xFF)
{
b32 >>= 8;
result += 8;
}
return (Square)(result + MS1BTable[b32]);
}
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;
}
std::string new_artifact()
{
if (one_in(2)) { // Generate a "tool" artifact
it_artifact_tool *art = new it_artifact_tool();
int form = rng(ARTTOOLFORM_NULL + 1, NUM_ARTTOOLFORMS - 1);
artifact_tool_form_datum *info = &(artifact_tool_form_data[form]);
art->create_name(info->name);
art->color = info->color;
art->sym = info->sym;
art->materials.push_back(info->material);
art->volume = rng(info->volume_min, info->volume_max);
art->weight = rng(info->weight_min, info->weight_max);
// Set up the basic weapon type
artifact_weapon_datum *weapon = &(artifact_weapon_data[info->base_weapon]);
art->melee_dam = rng(weapon->bash_min, weapon->bash_max);
art->melee_cut = rng(weapon->cut_min, weapon->cut_max);
art->m_to_hit = rng(weapon->to_hit_min, weapon->to_hit_max);
if( weapon->tag != "" ) {
art->item_tags.insert(weapon->tag);
}
// Add an extra weapon perhaps?
if (one_in(2)) {
int select = rng(0, 2);
if (info->extra_weapons[select] != ARTWEAP_NULL) {
weapon = &(artifact_weapon_data[ info->extra_weapons[select] ]);
art->volume += weapon->volume;
art->weight += weapon->weight;
art->melee_dam += rng(weapon->bash_min, weapon->bash_max);
art->melee_cut += rng(weapon->cut_min, weapon->cut_max);
art->m_to_hit += rng(weapon->to_hit_min, weapon->to_hit_max);
if( weapon->tag != "" ) {
art->item_tags.insert(weapon->tag);
}
std::stringstream newname;
newname << weapon->adjective << " " << info->name;
art->create_name(newname.str());
}
}
// CHOP is a sword, STAB is a dagger
if( art->item_tags.count( "CHOP" ) > 0 ) {
art->item_tags.insert( "SHEATH_SWORD" );
}
if( art->item_tags.count( "STAB" ) > 0 ) {
art->item_tags.insert( "SHEATH_KNIFE" );
}
art->description = string_format(
_("This is the %s.\nIt is the only one of its kind.\nIt may have unknown powers; try activating them."),
art->nname(1).c_str());
// Finally, pick some powers
art_effect_passive passive_tmp = AEP_NULL;
art_effect_active active_tmp = AEA_NULL;
int num_good = 0, num_bad = 0, value = 0;
std::vector<art_effect_passive> good_effects = fill_good_passive();
std::vector<art_effect_passive> bad_effects = fill_bad_passive();
// Wielded effects first
while (!good_effects.empty() && !bad_effects.empty() &&
num_good < 3 && num_bad < 3 &&
(num_good < 1 || num_bad < 1 || one_in(num_good + 1) ||
one_in(num_bad + 1) || value > 1)) {
if (value < 1 && one_in(2)) { // Good
int index = rng(0, good_effects.size() - 1);
passive_tmp = good_effects[index];
good_effects.erase(good_effects.begin() + index);
num_good++;
} else if (!bad_effects.empty()) { // Bad effect
int index = rng(0, bad_effects.size() - 1);
passive_tmp = bad_effects[index];
bad_effects.erase(bad_effects.begin() + index);
num_bad++;
}
value += passive_effect_cost[passive_tmp];
art->effects_wielded.push_back(passive_tmp);
}
// Next, carried effects; more likely to be just bad
num_good = 0;
num_bad = 0;
value = 0;
good_effects = fill_good_passive();
bad_effects = fill_bad_passive();
while (one_in(2) && !good_effects.empty() && !bad_effects.empty() &&
num_good < 3 && num_bad < 3 &&
((num_good > 2 && one_in(num_good + 1)) || num_bad < 1 ||
one_in(num_bad + 1) || value > 1)) {
if (value < 1 && one_in(3)) { // Good
int index = rng(0, good_effects.size() - 1);
passive_tmp = good_effects[index];
good_effects.erase(good_effects.begin() + index);
num_good++;
} else { // Bad effect
int index = rng(0, bad_effects.size() - 1);
passive_tmp = bad_effects[index];
bad_effects.erase(bad_effects.begin() + index);
num_bad++;
}
value += passive_effect_cost[passive_tmp];
art->effects_carried.push_back(passive_tmp);
}
// Finally, activated effects; not necessarily good or bad
num_good = 0;
num_bad = 0;
value = 0;
art->def_charges = 0;
art->max_charges = 0;
std::vector<art_effect_active> good_a_effects = fill_good_active();
std::vector<art_effect_active> bad_a_effects = fill_bad_active();
while (!good_a_effects.empty() && !bad_a_effects.empty() &&
num_good < 3 && num_bad < 3 &&
(value > 3 || (num_bad > 0 && num_good == 0) ||
!one_in(3 - num_good) || !one_in(3 - num_bad))) {
if (!one_in(3) && value <= 1) { // Good effect
int index = rng(0, good_a_effects.size() - 1);
active_tmp = good_a_effects[index];
good_a_effects.erase(good_a_effects.begin() + index);
num_good++;
value += active_effect_cost[active_tmp];
} else { // Bad effect
int index = rng(0, bad_a_effects.size() - 1);
active_tmp = bad_a_effects[index];
bad_a_effects.erase(bad_a_effects.begin() + index);
num_bad++;
value += active_effect_cost[active_tmp];
}
art->effects_activated.push_back(active_tmp);
art->max_charges += rng(1, 3);
}
art->def_charges = art->max_charges;
art->rand_charges.push_back(art->max_charges);
// If we have charges, pick a recharge mechanism
if (art->max_charges > 0) {
art->charge_type = art_charge( rng(ARTC_NULL + 1, NUM_ARTCS - 1) );
}
if (one_in(8) && num_bad + num_good >= 4) {
art->charge_type = ARTC_NULL; // 1 in 8 chance that it can't recharge!
}
item_controller->add_item_type( art );
return art->id;
} else { // Generate an armor artifact
it_artifact_armor *art = new it_artifact_armor();
int form = rng(ARTARMFORM_NULL + 1, NUM_ARTARMFORMS - 1);
artifact_armor_form_datum *info = &(artifact_armor_form_data[form]);
art->create_name(info->name);
art->sym = '['; // Armor is always [
art->color = info->color;
art->materials.push_back(info->material);
art->volume = info->volume;
art->weight = info->weight;
art->melee_dam = info->melee_bash;
art->melee_cut = info->melee_cut;
art->m_to_hit = info->melee_hit;
art->covers = info->covers;
art->encumber = info->encumb;
art->coverage = info->coverage;
art->thickness = info->thickness;
art->env_resist = info->env_resist;
art->warmth = info->warmth;
art->storage = info->storage;
std::stringstream description;
description << string_format(info->plural ?
_("This is the %s.\nThey are the only ones of their kind.") :
_("This is the %s.\nIt is the only one of its kind."),
art->nname(1).c_str());
// Modify the armor further
if (!one_in(4)) {
int index = rng(0, 4);
if (info->available_mods[index] != ARMORMOD_NULL) {
artifact_armor_mod mod = info->available_mods[index];
artifact_armor_form_datum *modinfo = &(artifact_armor_mod_data[mod]);
if (modinfo->volume >= 0 || art->volume > unsigned(abs(modinfo->volume))) {
art->volume += modinfo->volume;
} else {
art->volume = 1;
}
if (modinfo->weight >= 0 || art->weight > unsigned(abs(modinfo->weight))) {
art->weight += modinfo->weight;
} else {
art->weight = 1;
}
art->encumber += modinfo->encumb;
if (modinfo->coverage > 0 || art->coverage > abs(modinfo->coverage)) {
art->coverage += modinfo->coverage;
} else {
art->coverage = 0;
}
if (modinfo->thickness > 0 || art->thickness > abs(modinfo->thickness)) {
art->thickness += modinfo->thickness;
} else {
art->thickness = 0;
}
if (modinfo->env_resist > 0 || art->env_resist > abs(modinfo->env_resist)) {
art->env_resist += modinfo->env_resist;
} else {
art->env_resist = 0;
}
art->warmth += modinfo->warmth;
if (modinfo->storage > 0 || art->storage > abs(modinfo->storage)) {
art->storage += modinfo->storage;
} else {
art->storage = 0;
}
description << string_format(info->plural ?
_("\nThey are %s") :
_("\nIt is %s"),
modinfo->name.c_str());
}
}
art->description = description.str();
// Finally, pick some effects
int num_good = 0, num_bad = 0, value = 0;
art_effect_passive passive_tmp = AEP_NULL;
std::vector<art_effect_passive> good_effects = fill_good_passive();
std::vector<art_effect_passive> bad_effects = fill_bad_passive();
while (!good_effects.empty() && !bad_effects.empty() &&
num_good < 3 && num_bad < 3 &&
(num_good < 1 || one_in(num_good * 2) || value > 1 ||
(num_bad < 3 && !one_in(3 - num_bad)))) {
if (value < 1 && one_in(2)) { // Good effect
int index = rng(0, good_effects.size() - 1);
passive_tmp = good_effects[index];
good_effects.erase(good_effects.begin() + index);
num_good++;
} else { // Bad effect
int index = rng(0, bad_effects.size() - 1);
passive_tmp = bad_effects[index];
bad_effects.erase(bad_effects.begin() + index);
num_bad++;
}
value += passive_effect_cost[passive_tmp];
art->effects_worn.push_back(passive_tmp);
}
item_controller->add_item_type( art );
return art->id;
}
}
/**
* Whenever a hazard collides with an entity, this function resolves the effect
* Called by HazardManager
*
* Returns false on miss
*/
bool Entity::takeHit(const Hazard &h) {
//check if this enemy should be affected by this hazard based on the category
if(!powers->powers[h.power_index].target_categories.empty() && !stats.hero) {
//the power has a target category requirement, so if it doesnt match, dont continue
bool match_found = false;
for (unsigned int i=0; i<stats.categories.size(); i++) {
if(std::find(powers->powers[h.power_index].target_categories.begin(), powers->powers[h.power_index].target_categories.end(), stats.categories[i]) != powers->powers[h.power_index].target_categories.end()) {
match_found = true;
}
}
if(!match_found)
return false;
}
//if the target is already dead, they cannot be hit
if ((stats.cur_state == ENEMY_DEAD || stats.cur_state == ENEMY_CRITDEAD) && !stats.hero)
return false;
if(stats.cur_state == AVATAR_DEAD && stats.hero)
return false;
//if the target is an enemy and they are not already in combat, activate a beacon to draw other enemies into battle
if (!stats.in_combat && !stats.hero && !stats.hero_ally) {
stats.join_combat = true;
stats.in_combat = true;
powers->activate(stats.power_index[BEACON], &stats, stats.pos); //emit beacon
}
// exit if it was a beacon (to prevent stats.targeted from being set)
if (powers->powers[h.power_index].beacon) return false;
// prepare the combat text
CombatText *combat_text = comb;
// if it's a miss, do nothing
int accuracy = h.accuracy;
if(powers->powers[h.power_index].mod_accuracy_mode == STAT_MODIFIER_MODE_MULTIPLY)
accuracy = accuracy * powers->powers[h.power_index].mod_accuracy_value / 100;
else if(powers->powers[h.power_index].mod_accuracy_mode == STAT_MODIFIER_MODE_ADD)
accuracy += powers->powers[h.power_index].mod_accuracy_value;
else if(powers->powers[h.power_index].mod_accuracy_mode == STAT_MODIFIER_MODE_ABSOLUTE)
accuracy = powers->powers[h.power_index].mod_accuracy_value;
int avoidance = 0;
if(!powers->powers[h.power_index].trait_avoidance_ignore) {
avoidance = stats.get(STAT_AVOIDANCE);
if (stats.effects.triggered_block) avoidance *= 2;
}
int true_avoidance = 100 - (accuracy + 25 - avoidance);
//if we are using an absolute accuracy, offset the constant 25 added to the accuracy
if(powers->powers[h.power_index].mod_accuracy_mode == STAT_MODIFIER_MODE_ABSOLUTE)
true_avoidance += 25;
clampFloor(true_avoidance, MIN_AVOIDANCE);
clampCeil(true_avoidance, MAX_AVOIDANCE);
if (percentChance(true_avoidance)) {
combat_text->addMessage(msg->get("miss"), stats.pos, COMBAT_MESSAGE_MISS);
return false;
}
// calculate base damage
int dmg = randBetween(h.dmg_min, h.dmg_max);
if(powers->powers[h.power_index].mod_damage_mode == STAT_MODIFIER_MODE_MULTIPLY)
dmg = dmg * powers->powers[h.power_index].mod_damage_value_min / 100;
else if(powers->powers[h.power_index].mod_damage_mode == STAT_MODIFIER_MODE_ADD)
dmg += powers->powers[h.power_index].mod_damage_value_min;
else if(powers->powers[h.power_index].mod_damage_mode == STAT_MODIFIER_MODE_ABSOLUTE)
dmg = randBetween(powers->powers[h.power_index].mod_damage_value_min, powers->powers[h.power_index].mod_damage_value_max);
// apply elemental resistance
if (h.trait_elemental >= 0 && unsigned(h.trait_elemental) < stats.vulnerable.size()) {
unsigned i = h.trait_elemental;
int vulnerable = stats.vulnerable[i];
clampFloor(vulnerable,MIN_RESIST);
if (stats.vulnerable[i] < 100)
clampCeil(vulnerable,MAX_RESIST);
dmg = (dmg * vulnerable) / 100;
}
if (!h.trait_armor_penetration) { // armor penetration ignores all absorption
// substract absorption from armor
int absorption = randBetween(stats.get(STAT_ABS_MIN), stats.get(STAT_ABS_MAX));
if (stats.effects.triggered_block) {
absorption += absorption + stats.get(STAT_ABS_MAX); // blocking doubles your absorb amount
}
if (absorption > 0 && dmg > 0) {
int abs = absorption;
if ((abs*100)/dmg < MIN_BLOCK)
absorption = (dmg * MIN_BLOCK) /100;
if ((abs*100)/dmg > MAX_BLOCK)
absorption = (dmg * MAX_BLOCK) /100;
if ((abs*100)/dmg < MIN_ABSORB && !stats.effects.triggered_block)
absorption = (dmg * MIN_ABSORB) /100;
if ((abs*100)/dmg > MAX_ABSORB && !stats.effects.triggered_block)
absorption = (dmg * MAX_ABSORB) /100;
// Sometimes, the absorb limits cause absorbtion to drop to 1
// This could be confusing to a player that has something with an absorb of 1 equipped
// So we round absorption up in this case
if (absorption == 0) absorption = 1;
}
dmg = dmg - absorption;
if (dmg <= 0) {
dmg = 0;
if (h.trait_elemental < 0) {
if (stats.effects.triggered_block && MAX_BLOCK < 100) dmg = 1;
else if (!stats.effects.triggered_block && MAX_ABSORB < 100) dmg = 1;
}
else {
if (MAX_RESIST < 100) dmg = 1;
}
play_sfx_block = true;
if (activeAnimation->getName() == "block")
resetActiveAnimation();
}
}
// check for crits
int true_crit_chance = h.crit_chance;
if(powers->powers[h.power_index].mod_crit_mode == STAT_MODIFIER_MODE_MULTIPLY)
true_crit_chance = true_crit_chance * powers->powers[h.power_index].mod_crit_value / 100;
else if(powers->powers[h.power_index].mod_crit_mode == STAT_MODIFIER_MODE_ADD)
true_crit_chance += powers->powers[h.power_index].mod_crit_value;
else if(powers->powers[h.power_index].mod_crit_mode == STAT_MODIFIER_MODE_ABSOLUTE)
true_crit_chance = powers->powers[h.power_index].mod_crit_value;
if (stats.effects.stun || stats.effects.speed < 100)
true_crit_chance += h.trait_crits_impaired;
bool crit = percentChance(true_crit_chance);
if (crit) {
dmg = dmg + h.dmg_max;
if(!stats.hero)
mapr->shaky_cam_ticks = MAX_FRAMES_PER_SEC/2;
}
if(stats.hero)
combat_text->addMessage(dmg, stats.pos, COMBAT_MESSAGE_TAKEDMG);
else {
if(crit)
combat_text->addMessage(dmg, stats.pos, COMBAT_MESSAGE_CRIT);
else
combat_text->addMessage(dmg, stats.pos, COMBAT_MESSAGE_GIVEDMG);
}
// temporarily save the current HP for calculating HP/MP steal on final blow
int prev_hp = stats.hp;
// apply damage
stats.takeDamage(dmg);
// after effects
if (dmg > 0) {
// damage always breaks stun
stats.effects.removeEffectType(EFFECT_STUN);
if (stats.hp > 0) {
powers->effect(&stats, h.src_stats, h.power_index,h.source_type);
}
if (!stats.effects.immunity) {
if (h.hp_steal != 0) {
int steal_amt = (std::min(dmg, prev_hp) * h.hp_steal) / 100;
if (steal_amt == 0) steal_amt = 1;
combat_text->addMessage(msg->get("+%d HP",steal_amt), h.src_stats->pos, COMBAT_MESSAGE_BUFF);
h.src_stats->hp = std::min(h.src_stats->hp + steal_amt, h.src_stats->get(STAT_HP_MAX));
}
if (h.mp_steal != 0) {
int steal_amt = (std::min(dmg, prev_hp) * h.mp_steal) / 100;
if (steal_amt == 0) steal_amt = 1;
combat_text->addMessage(msg->get("+%d MP",steal_amt), h.src_stats->pos, COMBAT_MESSAGE_BUFF);
h.src_stats->mp = std::min(h.src_stats->mp + steal_amt, h.src_stats->get(STAT_MP_MAX));
}
}
}
// post effect power
if (h.post_power > 0 && dmg > 0) {
powers->activate(h.post_power, h.src_stats, stats.pos);
}
// loot
if (dmg > 0 && !h.loot.empty()) {
for (unsigned i=0; i<h.loot.size(); i++) {
powers->loot.push_back(h.loot[i]);
powers->loot.back().x = (int)stats.pos.x;
powers->loot.back().y = (int)stats.pos.y;
}
}
// interrupted to new state
if (dmg > 0) {
bool chance_poise = percentChance(stats.get(STAT_POISE));
if(stats.hp <= 0) {
stats.effects.triggered_death = true;
if(stats.hero)
stats.cur_state = AVATAR_DEAD;
else {
doRewards(h.source_type);
if (crit)
stats.cur_state = ENEMY_CRITDEAD;
else
stats.cur_state = ENEMY_DEAD;
mapr->collider.unblock(stats.pos.x,stats.pos.y);
}
}
// don't go through a hit animation if stunned
else if (!stats.effects.stun && !chance_poise) {
play_sfx_hit = true;
if(!chance_poise && stats.cooldown_hit_ticks == 0) {
if(stats.hero)
stats.cur_state = AVATAR_HIT;
else
stats.cur_state = ENEMY_HIT;
stats.cooldown_hit_ticks = stats.cooldown_hit;
if (stats.untransform_on_hit)
stats.transform_duration = 0;
}
// roll to see if the enemy's ON_HIT power is casted
if (percentChance(stats.power_chance[ON_HIT])) {
powers->activate(stats.power_index[ON_HIT], &stats, stats.pos);
}
}
// just play the hit sound
else
play_sfx_hit = true;
}
return true;
}
bool TestImporter::parseDDSG( QString filename )
{
QString outputPrefix = fileInDirectory( m_outputDirectory, "Test Importer" );
FileStream edgesData( outputPrefix + "_mapped_edges" );
FileStream routingCoordinatesData( outputPrefix + "_routing_coordinates" );
FileStream edgePathsData( outputPrefix + "_paths" );
FileStream wayRefsData( outputPrefix + "_way_refs" );
FileStream wayTypesData( outputPrefix + "_way_types" );
FileStream penaltyData( outputPrefix + "_penalties" );
FileStream boundingBoxData( outputPrefix + "_bounding_box" );
if ( !edgesData.open( QIODevice::WriteOnly ) )
return false;
if ( !routingCoordinatesData.open( QIODevice::WriteOnly ) )
return false;
if ( !edgePathsData.open( QIODevice::WriteOnly ) )
return false;
if ( !wayRefsData.open( QIODevice::WriteOnly ) )
return false;
if ( !wayTypesData.open( QIODevice::WriteOnly ) )
return false;
if ( !penaltyData.open( QIODevice::WriteOnly ) )
return false;
if ( !boundingBoxData.open( QIODevice::WriteOnly ) )
return false;
QFile ddsgFile( filename );
if ( !openQFile( &ddsgFile, QIODevice::ReadOnly ) )
return false;
QTextStream inputStream( &ddsgFile );
QString id;
inputStream >> id;
if ( id != "d" ) {
qCritical() << "Not a ddsg file";
return false;
}
wayRefsData << "";
wayTypesData << "";
unsigned nodes;
unsigned edges;
inputStream >> nodes >> edges;
std::vector< SimpleEdge > simpleEdges;
qDebug() << "Test Importer:" << "reading" << nodes << " nodes and" << edges << "edges";
for ( unsigned i = 0; i < edges; i++ ) {
unsigned from;
unsigned to;
unsigned weight;
unsigned direction;
inputStream >> from >> to >> weight >> direction;
if ( direction == 3 )
continue;
if ( from == to )
continue;
SimpleEdge newEdge;
newEdge.source = from;
newEdge.target = to;
newEdge.bidirectional = direction == 1;
newEdge.distance = weight / 10.0;
newEdge.forward = direction == 1 || direction == 0;
newEdge.backward = direction == 2 || direction == 0;
if ( from > to ) {
std::swap( newEdge.source, newEdge.target );
std::swap( newEdge.forward, newEdge.backward );
}
simpleEdges.push_back( newEdge );
}
std::sort( simpleEdges.begin(), simpleEdges.end(), SimpleEdge::sortToMerge );
unsigned edgesLeft = 1;
for ( unsigned i = 1; i < simpleEdges.size(); i++ ) {
SimpleEdge& edge = simpleEdges[i];
SimpleEdge& otherEdge = simpleEdges[edgesLeft - 1];
simpleEdges[edgesLeft++] = edge;
if ( edge.source != otherEdge.source )
continue;
if ( edge.target != otherEdge.target )
continue;
if ( edge.distance != otherEdge.distance )
continue;
edgesLeft--;
otherEdge.forward |= edge.forward;
otherEdge.backward |= edge.backward;
}
simpleEdges.resize( edgesLeft );
unsigned biEdges = 0;
for ( unsigned i = 0; i < simpleEdges.size(); i++ ) {
if ( !simpleEdges[i].forward ) {
std::swap( simpleEdges[i].source, simpleEdges[i].target );
std::swap( simpleEdges[i].forward, simpleEdges[i].backward );
}
simpleEdges[i].bidirectional = simpleEdges[i].forward && simpleEdges[i].backward;
biEdges += simpleEdges[i].bidirectional ? 1 : 0;
assert( simpleEdges[i].forward );
}
qDebug() << "Test Importer:" << biEdges << "bidirectional edges";
qDebug() << "Test Importer:" << edges - biEdges * 2 << "unidirectional edges";
qDebug() << "Test Importer:" << edges - edgesLeft << "edges removed";
std::sort( simpleEdges.begin(), simpleEdges.end() );
std::vector< char > in( nodes, 0 );
std::vector< char > out( nodes, 0 );
std::vector< char > bi( nodes, 0 );
qDebug() << "Test Importer:" << "writing" << simpleEdges.size() << "edges";
for ( unsigned i = 0; i < simpleEdges.size(); i++ ) {
edgesData << simpleEdges[i].source << simpleEdges[i].target << simpleEdges[i].bidirectional << simpleEdges[i].distance;
edgesData << unsigned( 0 ) << unsigned( 0 ) << unsigned ( 0 ); // name
edgesData << unsigned( 0 ) << unsigned( 0 ); // path
edgesData << unsigned( 0 ) << unsigned( 0 ); // address
edgesData << qint8( out[simpleEdges[i].source]++ ) << qint8( in[simpleEdges[i].target]++ );
if ( simpleEdges[i].bidirectional ) {
in[simpleEdges[i].source]++;
out[simpleEdges[i].target]++;
bi[simpleEdges[i].source]++;
bi[simpleEdges[i].target]++;
assert( in[simpleEdges[i].source] == out[simpleEdges[i].source] );
assert( in[simpleEdges[i].target] == out[simpleEdges[i].target] );
}
}
long long penalties = 0;
long long uturns = 0;
qDebug() << "Test Importer:" << "forbid uturns:" << m_settings.forbidUTurn;
qDebug() << "Test Importer:" << "uturn penalty:" << m_settings.uTurnPenalty;
for ( unsigned i = 0; i < nodes; i++ ) {
routingCoordinatesData << unsigned( 0 ) << unsigned( 0 );
penaltyData << unsigned( in[i] ) << unsigned( out[i] );
for ( int from = 0; from < in[i]; from++ ) {
for ( int to = 0; to < out[i]; to++ ) {
double penalty = 0;
if ( from == to && from < bi[i] ) {
uturns++;
if ( m_settings.forbidUTurn )
penalty = -1;
else
penalty = m_settings.uTurnPenalty;
}
penaltyData << penalty;
penalties++;
}
}
}
qDebug() << "Test Importer:" << "wrote" << penalties << "penalties";
qDebug() << "Test Importer:" << uturns << "uturns";
return true;
}
void TestAARHUD::UpdateHighDetailData(int baseWidth, float& curYPos)
{
if (*mHUDState == HUDState::MAXIMUM)
{
char clin[HUDCONTROLMAXTEXTSIZE]; // general buffer to print
char lastTagStr[HUDCONTROLMAXTEXTSIZE];
char numTagsStr[HUDCONTROLMAXTEXTSIZE];
char lastFrameStr[HUDCONTROLMAXTEXTSIZE];
char numFramesStr[HUDCONTROLMAXTEXTSIZE];
// Determine num tags, num frames, etc...
if (dtGame::LogStateEnumeration::LOGGER_STATE_IDLE == mLogController->GetLastKnownStatus().GetStateEnum())
{
snprintf(numTagsStr, HUDCONTROLMAXTEXTSIZE, "Num Tags: NA");
snprintf(lastTagStr, HUDCONTROLMAXTEXTSIZE, " (Last: NA)");
snprintf(numFramesStr, HUDCONTROLMAXTEXTSIZE, "Num Frames: NA");
snprintf(lastFrameStr, HUDCONTROLMAXTEXTSIZE, " (Last: NA)");
}
else // compute data needed for both LOGGER_STATE_PLAYBACK or LOGGER_STATE_RECORD
{
// TAGS - num tags and last tag
const std::vector<dtGame::LogTag> tags = mLogController->GetLastKnownTagList();
snprintf(numTagsStr, HUDCONTROLMAXTEXTSIZE, "Num Tags: %u", unsigned(tags.size()));
if (tags.size() > 0)
{
snprintf(lastTagStr, HUDCONTROLMAXTEXTSIZE, " (Last: None)");
for (unsigned int i = 0; i < tags.size(); i ++)
{
const dtGame::LogTag tag = tags[i];
//double tagTime = tags[i].GetSimTimeStamp();
//double simTime = mClientGM->GetSimulationTime();
if (tags[i].GetSimTimeStamp() <= GetGameManager()->GetSimulationTime())
{
std::string temp = (tags[i]).GetName();
snprintf(lastTagStr, HUDCONTROLMAXTEXTSIZE, " (%s)", temp.c_str());//(tags[tags.size()-1]).GetName());
}
}
}
else
{
snprintf(lastTagStr, HUDCONTROLMAXTEXTSIZE, " (----)");
}
// FRAMES - num frames and last frame
const std::vector<dtGame::LogKeyframe> frames = mLogController->GetLastKnownKeyframeList();
snprintf(numFramesStr, HUDCONTROLMAXTEXTSIZE, "Num Frames: %u", unsigned(frames.size()));
if (frames.size() > 0)
{
snprintf(lastFrameStr, HUDCONTROLMAXTEXTSIZE, " (Last: None)");
for (unsigned int i = 0; i < frames.size(); i ++)
{
if (frames[i].GetSimTimeStamp() <= GetGameManager()->GetSimulationTime())
{
std::string temp = (frames[i]).GetName();
snprintf(lastFrameStr, HUDCONTROLMAXTEXTSIZE, " (%s)", temp.c_str());
}
}
}
else
{
snprintf(lastFrameStr, HUDCONTROLMAXTEXTSIZE, " (----)");
}
}
// Num Messages
snprintf(clin, HUDCONTROLMAXTEXTSIZE, "Num Msgs: %lu", mLogController->GetLastKnownStatus().GetNumMessages());
curYPos += (mTextHeight + 2) * 2;
UpdateStaticText(mNumMessagesText, clin, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Record Duration
snprintf(clin, HUDCONTROLMAXTEXTSIZE, "Duration: %.2f", mLogController->GetLastKnownStatus().GetCurrentRecordDuration());
curYPos += mTextHeight + 2;
UpdateStaticText(mRecordDurationText, clin, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Number of Tags
curYPos += mTextHeight + 2;
UpdateStaticText(mNumTagsText, numTagsStr, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Last Tag
curYPos += mTextHeight + 2;
UpdateStaticText(mLastTagText, lastTagStr, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Num Frames
curYPos += mTextHeight + 2;
UpdateStaticText(mNumFramesText, numFramesStr, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Num Frames
curYPos += mTextHeight + 2;
UpdateStaticText(mLastFrameText, lastFrameStr, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Current Log
snprintf(clin, HUDCONTROLMAXTEXTSIZE, "LogFile: %s", mLogController->GetLastKnownStatus().GetLogFile().c_str());
curYPos += mTextHeight + 2;
UpdateStaticText(mCurLogText, clin, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
// Current Map
snprintf(clin, HUDCONTROLMAXTEXTSIZE, "CurMap: %s", mLogController->GetLastKnownStatus().GetActiveMaps()[0].c_str());
curYPos += mTextHeight + 2;
UpdateStaticText(mCurMapText, clin, -1.0f, -1.0f, -1.0f, baseWidth, curYPos);
}
}
void NextCommand::execute(const Arguments& args, NSDebuggingContext::Context& ctx)
{
mili::assert_throw<NSCommon::InvalidArgumentNumbers>(0u == args.size() || args.size() == unsigned(NumberOfArgs));
const auto instanceNmbr = (args.size() == 0u) ? ctx.getCurrentInstance() : mili::from_string<NSCommon::InstanceId>(args[InstanceNumber]);
const auto instance = ctx.getInstance(instanceNmbr).lock();
mili::assert_throw<NSCommon::InstanceNoLongerAlive>(bool(instance));
auto nextTermination = instance->next();
nextTermination.wait();
}
void LoadValueEnum(unsigned i, T value) {
LoadValueEnum(i, unsigned(value));
}
void functional(typename enable_if< O <= unsigned(4) >::type* = 0) {
}
bool MCCrypt_rsa_op(bool p_encrypt, RSA_KEYTYPE p_key_type, const char *p_message_in, uint32_t p_message_in_length,
const char *p_key, uint32_t p_key_length, const char *p_passphrase,
char *&r_message_out, uint32_t &r_message_out_length, char *&r_result, uint32_t &r_error)
{
bool t_success = true;
EVP_PKEY *t_key = NULL;
RSA *t_rsa = NULL;
int32_t t_rsa_size;
uint8_t *t_output_buffer = NULL;
int32_t t_output_length;
if (!InitSSLCrypt())
{
t_success = false;
MCCStringClone("error: ssl library initialization failed", r_result);
}
if (t_success)
{
if (!load_pem_key(p_key, p_key_length, p_key_type, p_passphrase, t_key))
{
t_success = false;
MCCStringClone("error: invalid key", r_result);
}
}
if (t_success)
{
t_rsa = EVP_PKEY_get1_RSA(t_key);
if (t_rsa == NULL)
{
t_success = false;
MCCStringClone("error: not an RSA key", r_result);
}
}
if (t_success)
{
t_rsa_size = RSA_size(t_rsa);
if (!MCMemoryAllocate(t_rsa_size, t_output_buffer))
{
t_success = false;
r_error = EE_NO_MEMORY;
}
}
int (*t_rsa_func)(int, const unsigned char*, unsigned char*, RSA*, int) = NULL;
if (t_success)
{
if (p_encrypt)
{
if (p_key_type == RSAKEY_PRIVKEY)
t_rsa_func = RSA_private_encrypt;
else
t_rsa_func = RSA_public_encrypt;
if (p_message_in_length >= unsigned(t_rsa_size - 11))
{
t_success = false;
MCCStringClone("error: message too large", r_result);
}
}
else
{
if (p_key_type == RSAKEY_PRIVKEY)
t_rsa_func = RSA_private_decrypt;
else
t_rsa_func = RSA_public_decrypt;
if (p_message_in_length != t_rsa_size)
{
t_success = false;
MCCStringClone("error: invalid message size", r_result);
}
}
}
if (t_success)
{
t_output_length = t_rsa_func(p_message_in_length, (const uint8_t*)p_message_in, t_output_buffer, t_rsa, RSA_PKCS1_PADDING);
if (t_output_length < 0)
{
t_success = false;
MCCStringClone("error: SSL operation failed", r_result);
}
}
if (t_rsa != NULL)
RSA_free(t_rsa);
if (t_key != NULL)
EVP_PKEY_free(t_key);
if (t_success)
{
r_message_out = (char*)t_output_buffer;
r_message_out_length = t_output_length;
}
else
{
uint32_t t_err;
t_err = ERR_get_error();
if (t_err)
{
const char *t_ssl_error = ERR_reason_error_string(t_err);
MCCStringAppendFormat(r_result, " (SSL error: %s)", t_ssl_error);
}
MCMemoryDeallocate(t_output_buffer);
}
return t_success;
}
inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
bool DFInstanceLinux::find_running_copy(bool connect_anyway) {
// find PID of DF
TRACE << "attempting to find running copy of DF by executable name";
QProcess *proc = new QProcess(this);
QStringList args;
args << "dwarfort.exe"; // 0.31.04 and earlier
args << "Dwarf_Fortress"; // 0.31.05+
proc->start("pidof", args);
proc->waitForFinished(1000);
if (proc->exitCode() == 0) { //found it
QByteArray out = proc->readAllStandardOutput();
QStringList str_pids = QString(out).split(" ");
str_pids.sort();
if(str_pids.count() > 1){
m_pid = QInputDialog::getItem(0, tr("Warning"),tr("Multiple Dwarf Fortress processes found, please choose the process to use."),str_pids,str_pids.count()-1,false).toInt();
}else{
m_pid = str_pids.at(0).toInt();
}
m_memory_file.setFileName(QString("/proc/%1/mem").arg(m_pid));
TRACE << "USING PID:" << m_pid;
} else {
QMessageBox::warning(0, tr("Warning"),
tr("Unable to locate a running copy of Dwarf "
"Fortress, are you sure it's running?"));
LOGW << "can't find running copy";
m_is_ok = false;
return m_is_ok;
}
m_inject_addr = unsigned(-1);
m_alloc_start = 0;
m_alloc_end = 0;
map_virtual_memory();
//qDebug() << "LOWEST ADDR:" << hex << lowest_addr;
//DUMP LIST OF MEMORY RANGES
/*
QPair<uint, uint> tmp_pair;
foreach(tmp_pair, m_regions) {
LOGD << "RANGE start:" << hex << tmp_pair.first << "end:" << tmp_pair.second;
}*/
VIRTADDR m_base_addr = read_addr(m_lowest_address + 0x18);
LOGD << "base_addr:" << m_base_addr << "HEX" << hex << m_base_addr;
m_is_ok = m_base_addr > 0;
uint checksum = calculate_checksum();
LOGI << "DF's checksum is" << hexify(checksum);
if (m_is_ok) {
m_layout = get_memory_layout(hexify(checksum).toLower(), !connect_anyway);
}
//Get dwarf fortress directory
m_df_dir = QDir(QFileInfo(QString("/proc/%1/cwd").arg(m_pid)).symLinkTarget());
LOGI << "Dwarf fortress path:" << m_df_dir.absolutePath();
return m_is_ok || connect_anyway;
}
inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
//---------------------------------------------------------
char recoding_snp_data_under_coding_and_strand(char set2_val_, gtps_container *Set2, gtps_container *Set1, unsigned snp_in_set2, unsigned snp_in_set1, std::map<char, char*>* coding_polymorphism_map_, std::map<char, char> *alleleID_reverse_, unsigned *snp_position_error, char* snp_set2_codding_error, char* snp_set1_codding_error, int *error_amount_, unsigned *found_error_amount_snp, unsigned *snp_error_counter, bool forcestrand, std::map<std::string, std::string> *complemetntary)
{
//here is coding_polymorphism_map_->first = alleleID, coding_polymorphism_map_->second="name"
unsigned set2_val = unsigned(set2_val_);
char coding2_val=Set2->get_coding(snp_in_set2),
coding1_val=Set1->get_coding(snp_in_set1);
std::string coding2=(*coding_polymorphism_map_)[coding2_val],
coding1=(*coding_polymorphism_map_)[coding1_val];
CI iter=complemetntary->find(coding2);
bool two_nucl_is_complement=false;
if(iter != complemetntary->end())
{
two_nucl_is_complement=true;
}
//char coding2 = coding_set2_origin,
// coding1 = coding_set1_origin;
//
//std::string coding1=(*coding_polymorphism_map_)[coding_set1_origin],
// coding2=(*coding_polymorphism_map_)[coding_set2_origin];
char coding2_inverse_tmp[3] = {coding2[1], coding2[0], '\0'};
std::string coding2_inverse(coding2_inverse_tmp);
std::string coding2_fliped = (*coding_polymorphism_map_)[alleleID_reverse_->find(coding2_val)->second];
char coding2_fliped_inverse_tmp[3] = {coding2_fliped[1], coding2_fliped[0], '\0'};
std::string coding2_fliped_inverse(coding2_fliped_inverse_tmp);
char strand2 = Set2->get_strand(snp_in_set2);
char strand1 = Set1->get_strand(snp_in_set1);
//start
if(forcestrand)
{
if(strand1!=0 && strand2!=0)
{
FORCESTRAND:
if(strand1 != strand2)
{
coding2 = coding2_fliped;
}
if(coding1 == coding2)
{
return set2_val;
}
else
{
if(coding1 == coding2_inverse)
{
return inverse_genotype(set2_val);
}
else
{
coding_error(snp_in_set1,
coding1_val, coding2_val,
snp_error_counter,
snp_position_error,
snp_set2_codding_error,
snp_set1_codding_error,
found_error_amount_snp,
error_amount_);
return 0;
}
}
}
else
{
goto NOFORCESTRAND; //a komu seichas legko?
}
}
else
{
if(two_nucl_is_complement)
{
if(strand1!=0 && strand2!=0)
{
goto FORCESTRAND;
}
else
{
coding_error(snp_in_set1,
coding1_val, coding2_val,
snp_error_counter,
snp_position_error,
snp_set2_codding_error,
snp_set1_codding_error,
found_error_amount_snp,
error_amount_);
return 0;
}
}
else
{
// std::cout<<"NOFORCESTRAND\n";
NOFORCESTRAND:
if(coding1 == coding2)
{
// std::cout<<"coding1 == coding2\n";
return set2_val;
}
else
{
if(coding1 == coding2_inverse)
{
// std::cout<<"coding1 == coding2_inverse\n";
return inverse_genotype(set2_val);
}
else
{
if(coding1 == coding2_fliped)
{
// std::cout<<"coding1 == coding2_fliped\n";
return set2_val;
}
else
{
if(coding1 == coding2_fliped_inverse)
{
// std::cout<<"coding1 == coding2_fliped_inverse\n";
return inverse_genotype(set2_val);
}
else
{
// std::cout<<"error\n";
coding_error(snp_in_set1,
coding1_val, coding2_val,
snp_error_counter,
snp_position_error,
snp_set2_codding_error,
snp_set1_codding_error,
found_error_amount_snp,
error_amount_);
return 0;
}
}
}
}
}
}
//}
//}
//}
//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
/*
//recode in coding in accordance with strand
if(strand1 != strand2 &&
(user_want_to_look_at_strand || two_nucl_is_complement) &&
strand1 != 0 &&
strand2 != 0)
{
made_strand_flip = true;
coding_set2 = alleleID_reverse_->find(Set2->get_coding(snp_in_set2))->second;
}
else
{
coding_set2 = coding_set2_origin;
}
char *coding_set2_name;
if(coding_set1 != coding_set2)
{
//check wether is coding really same. For example coding_set1="AG" and coding_set2="GA" <- realy it is same polymorphism.
coding_set2_name = (*coding_polymorphism_map_)[coding_set2];
char coding_set2_name_new[3] = {coding_set2_name[1], coding_set2_name[0], '\0'};
if(std::string(coding_set1_name) == std::string(coding_set2_name_new))
{
switch(set1_val)
{
case 1:
set1_val=3;
break;
case 3:
set1_val=1;
break;
default:
break;
}
}
else
{
if(!made_strand_flip && strand1 != strand2)
{
coding_set2 = alleleID_reverse_->find(Set2->get_coding(snp_in_set2))->second;
} //flip strand if we have not done it yet
if(coding_set1 == coding_set2) {return char(set1_val);}
coding_set2_name = (*coding_polymorphism_map_)[coding_set2];
char coding_set2_name_new[3] = {coding_set2_name[1], coding_set2_name[0], '\0'};
if(std::string(coding_set1_name) == std::string(coding_set2_name_new))
{
switch(set1_val)
{
case 1:
set1_val=3;
break;
case 3:
set1_val=1;
break;
default:
break;
}
}
else
{
std::ostringstream error_stream;
if(*snp_error_counter == 0)
{
snp_position_error[*snp_error_counter] = snp_in_set1;
snp_set1_codding_error[*snp_error_counter] = coding_set1_origin;
snp_set2_codding_error[*snp_error_counter] = coding_set2_origin;
(*snp_error_counter)++;
*found_error_amount_snp = *snp_error_counter;
}
else if(snp_position_error[*snp_error_counter-1] != snp_in_set1)
{
snp_position_error[*snp_error_counter] = snp_in_set1;
snp_set1_codding_error[*snp_error_counter] = coding_set1_origin;
snp_set2_codding_error[*snp_error_counter] = coding_set2_origin;
(*snp_error_counter)++;
*found_error_amount_snp = *snp_error_counter;
}
if(*snp_error_counter >= *error_amount_)
{
Rprintf("ID:Error: Too many errors while merging sets (see error table). Change error_amount value to increase error-table size.\n");
*error_amount_=-1;
return char();
}
}
}
}
return char(set1_val);
*/
}
inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
CstrBuffer::CstrBuffer(int cap)
: m_buffer((char*)safe_malloc(cap + 1)), m_len(0), m_cap(cap) {
assert(unsigned(cap) <= kMaxCap);
}
inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
static int
l_task_index(lua_State *L)
{
const char *name = lua_tostring(L, 2);
if (name == nullptr)
return 0;
else if (StringIsEqual(name, "bearing")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!task_stats.task_valid || !vector_remaining.IsValid() ||
vector_remaining.distance <= 10) {
return 0;
}
Lua::Push(L, vector_remaining.bearing);
} else if (StringIsEqual(name, "bearing_diff")) {
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!basic.track_available || !task_stats.task_valid ||
!vector_remaining.IsValid() || vector_remaining.distance <= 10) {
return 0;
}
Lua::Push(L, vector_remaining.bearing - basic.track);
} else if (StringIsEqual(name, "radial")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!task_stats.task_valid || !vector_remaining.IsValid() ||
vector_remaining.distance <= 10) {
return 0;
}
Lua::Push(L, vector_remaining.bearing.Reciprocal());
} else if (StringIsEqual(name, "next_distance")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const GeoVector &vector_remaining = task_stats.current_leg.vector_remaining;
if (!task_stats.task_valid || !vector_remaining.IsValid())
return 0;
Lua::Push(L, vector_remaining.distance);
} else if (StringIsEqual(name, "next_distance_nominal")) {
const auto way_point = protected_task_manager != nullptr
? protected_task_manager->GetActiveWaypoint() : NULL;
if (!way_point) return 0;
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !basic.location_available) return 0;
const GeoVector vector(basic.location, way_point->location);
if (!vector.IsValid()) return 0;
Lua::Push(L, vector.distance);
} else if (StringIsEqual(name, "next_ete")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.current_leg.IsAchievable())
return 0;
assert(task_stats.current_leg.time_remaining_now >= 0);
Lua::Push(L, task_stats.current_leg.time_remaining_now);
} else if (StringIsEqual(name, "next_eta")) {
const auto &task_stats = CommonInterface::Calculated().task_stats;
const BrokenTime &now_local = CommonInterface::Calculated().date_time_local;
if (!task_stats.task_valid || !task_stats.current_leg.IsAchievable() ||
!now_local.IsPlausible()) {
return 0;
}
const BrokenTime t = now_local +
unsigned(task_stats.current_leg.solution_remaining.time_elapsed);
float time = t.hour + (float)(t.second/60);
Lua::Push(L, time);
} else if (StringIsEqual(name, "next_altitude_diff")) {
const auto &task_stats = CommonInterface::Calculated().task_stats;
const auto &next_solution = task_stats.current_leg.solution_remaining;
if (!task_stats.task_valid || !next_solution.IsAchievable())
return 0;
const auto &settings = CommonInterface::GetComputerSettings();
auto altitude_difference = next_solution.SelectAltitudeDifference(settings.task.glide);
Lua::Push(L, altitude_difference);
} else if (StringIsEqual(name, "nextmc0_altitude_diff")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.current_leg.solution_mc0.IsAchievable())
return 0;
const auto &settings = CommonInterface::GetComputerSettings();
auto altitude_difference = task_stats.current_leg.solution_mc0.SelectAltitudeDifference(settings.task.glide);
Lua::Push(L, altitude_difference);
} else if (StringIsEqual(name, "next_altitude_require")) {
const auto &task_stats = CommonInterface::Calculated().task_stats;
const auto &next_solution = task_stats.current_leg.solution_remaining;
if (!task_stats.task_valid || !next_solution.IsAchievable())
return 0;
Lua::Push(L, next_solution.GetRequiredAltitude());
} else if (StringIsEqual(name, "next_altitude_arrival")) {
const auto &basic = CommonInterface::Basic();
const auto &task_stats = CommonInterface::Calculated().task_stats;
const auto next_solution = task_stats.current_leg.solution_remaining;
if (!basic.NavAltitudeAvailable() ||
!task_stats.task_valid || !next_solution.IsAchievable()) {
return 0;
}
Lua::Push(L, next_solution.GetArrivalAltitude(basic.nav_altitude));
} else if (StringIsEqual(name, "next_gr")) {
if (!CommonInterface::Calculated().task_stats.task_valid)
return 0;
auto gradient = CommonInterface::Calculated().task_stats.current_leg.gradient;
if (gradient <= 0)
return 0;
if (::GradientValid(gradient))
Lua::Push(L, gradient);
else
return 0;
} else if (StringIsEqual(name, "final_distance")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.task_stats;
if (!task_stats.task_valid ||
!task_stats.current_leg.vector_remaining.IsValid() ||
!task_stats.total.remaining.IsDefined()) {
return 0;
}
Lua::Push(L, task_stats.total.remaining.GetDistance());
} else if (StringIsEqual(name, "final_ete")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.total.IsAchievable())
return 0;
assert(task_stats.total.time_remaining_now >= 0);
Lua::Push(L, task_stats.total.time_remaining_now);
} else if (StringIsEqual(name, "final_eta")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const BrokenTime &now_local = CommonInterface::Calculated().date_time_local;
if (!task_stats.task_valid || !task_stats.total.IsAchievable() ||
!now_local.IsPlausible())
return 0;
const BrokenTime t = now_local +
unsigned(task_stats.total.solution_remaining.time_elapsed);
float time = t.hour + (float)(t.minute/60);
Lua::Push(L, time);
} else if (StringIsEqual(name, "final_altitude_diff")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const auto &settings = CommonInterface::GetComputerSettings();
if (!task_stats.task_valid || !task_stats.total.solution_remaining.IsAchievable())
return 0;
auto altitude_difference =
task_stats.total.solution_remaining.SelectAltitudeDifference(settings.task.glide);
Lua::Push(L, altitude_difference);
} else if (StringIsEqual(name, "finalmc0_altitude_diff")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
const auto &settings = CommonInterface::GetComputerSettings();
if (!task_stats.task_valid || !task_stats.total.solution_mc0.IsAchievable())
return 0;
auto altitude_difference =
task_stats.total.solution_mc0.SelectAltitudeDifference(settings.task.glide);
Lua::Push(L, altitude_difference);
} else if (StringIsEqual(name, "final_altitude_require")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid ||
!task_stats.total.solution_remaining.IsOk()) {
return 0;
}
Lua::Push(L, task_stats.total.solution_remaining.GetRequiredAltitude());
} else if (StringIsEqual(name, "task_speed")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.total.travelled.IsDefined())
return 0;
Lua::Push(L, task_stats.total.travelled.GetSpeed());
} else if (StringIsEqual(name, "task_speed_achieved")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.total.remaining_effective.IsDefined())
return 0;
Lua::Push(L, task_stats.total.remaining_effective.GetSpeed());
} else if (StringIsEqual(name, "task_speed_instant")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid)
return -1;
Lua::Push(L, task_stats.inst_speed_fast);
} else if (StringIsEqual(name, "task_speed_hour")) {
const WindowStats &window = CommonInterface::Calculated().task_stats.last_hour;
if (window.duration < 0)
return 0;
Lua::Push(L, window.speed);
} else if (StringIsEqual(name, "final_gr")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid)
return 0;
auto gradient = task_stats.total.gradient;
if (gradient <= 0)
return 0;
if (::GradientValid(gradient))
Lua::Push(L, gradient);
else
return 0;
} else if (StringIsEqual(name, "aat_time")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
if (!task_stats.has_targets || !task_stats.total.IsAchievable())
return 0;
Lua::Push(L, common_stats.aat_time_remaining);
} else if (StringIsEqual(name, "aat_time_delta")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
if (!task_stats.has_targets || !task_stats.total.IsAchievable())
return 0;
assert(task_stats.total.time_remaining_start >= 0);
auto diff = task_stats.total.time_remaining_start -
common_stats.aat_time_remaining;
Lua::Push(L, diff);
} else if (StringIsEqual(name, "aat_distance")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
if (!task_stats.has_targets || !task_stats.total.planned.IsDefined())
return 0;
Lua::Push(L, task_stats.total.planned.GetDistance());
} else if (StringIsEqual(name, "aat_distance_max")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
if (!task_stats.has_targets)
return 0;
Lua::Push(L, task_stats.distance_max);
} else if (StringIsEqual(name, "aat_distance_min")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
if (!task_stats.has_targets)
return 0;
Lua::Push(L, task_stats.distance_min);
} else if (StringIsEqual(name, "aat_speed")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
if (!task_stats.has_targets || common_stats.aat_speed_target <= 0)
return 0;
Lua::Push(L, common_stats.aat_speed_target);
} else if (StringIsEqual(name, "aat_speed_max")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
if (!task_stats.has_targets || common_stats.aat_speed_max <= 0)
return 0;
Lua::Push(L, common_stats.aat_speed_max);
} else if (StringIsEqual(name, "aat_speed_min")) {
const auto &calculated = CommonInterface::Calculated();
const TaskStats &task_stats = calculated.ordered_task_stats;
const CommonStats &common_stats = calculated.common_stats;
if (!task_stats.has_targets ||
!task_stats.task_valid || common_stats.aat_speed_min <= 0)
return 0;
Lua::Push(L, common_stats.aat_speed_min);
} else if (StringIsEqual(name, "time_under_max_height")) {
const auto &calculated = CommonInterface::Calculated();
const auto &task_stats = calculated.ordered_task_stats;
const auto &common_stats = calculated.common_stats;
const double maxheight = protected_task_manager->GetOrderedTaskSettings().start_constraints.max_height;
if (!task_stats.task_valid || maxheight <= 0
|| !protected_task_manager
|| common_stats.TimeUnderStartMaxHeight <= 0) {
return 0;
}
const int time = (int)(CommonInterface::Basic().time -
common_stats.TimeUnderStartMaxHeight);
Lua::Push(L, time);
} else if (StringIsEqual(name, "next_etevmg")) {
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!basic.ground_speed_available || !task_stats.task_valid ||
!task_stats.current_leg.remaining.IsDefined()) {
return 0;
}
const auto d = task_stats.current_leg.remaining.GetDistance();
const auto v = basic.ground_speed;
if (!task_stats.task_valid ||
d <= 0 ||
v <= 0) {
return 0;
}
Lua::Push(L, d/v);
} else if (StringIsEqual(name, "final_etevmg")) {
const NMEAInfo &basic = CommonInterface::Basic();
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!basic.ground_speed_available || !task_stats.task_valid ||
!task_stats.total.remaining.IsDefined()) {
return 0;
}
const auto d = task_stats.total.remaining.GetDistance();
const auto v = basic.ground_speed;
if (!task_stats.task_valid ||
d <= 0 ||
v <= 0) {
return 0;
}
Lua::Push(L, d/v);
} else if (StringIsEqual(name, "cruise_efficiency")) {
const TaskStats &task_stats = CommonInterface::Calculated().task_stats;
if (!task_stats.task_valid || !task_stats.start.task_started)
return 0;
Lua::Push(L, task_stats.cruise_efficiency);
} else
return 0;
return 1;
}
inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
bool TASReso::SetHKLE(t_real h, t_real k, t_real l, t_real E)
{
static const t_real s_dPlaneDistTolerance = std::cbrt(tl::get_epsilon<t_real>());
ResoResults& resores = m_res[0];
//std::cout << "UB = " << m_opts.matUB << std::endl;
//std::cout << h << " " << k << " " << l << ", " << E << std::endl;
if(m_opts.matUB.size1() < 3 || m_opts.matUB.size2() < 3)
{
const char* pcErr = "Invalid UB matrix.";
tl::log_err(pcErr);
resores.strErr = pcErr;
resores.bOk = false;
return false;
}
t_vec vecHKLE;
if(m_opts.matUB.size1() == 3)
vecHKLE = tl::make_vec({h, k, l});
else
vecHKLE = tl::make_vec({h, k, l, E});
t_vec vecQ = ublas::prod(m_opts.matUB, vecHKLE);
if(vecQ.size() > 3)
vecQ.resize(3, true);
m_tofreso.Q = m_reso.Q = ublas::norm_2(vecQ) / angs;
m_tofreso.E = m_reso.E = E * meV;
//tl::log_info("kfix = ", m_dKFix, ", E = ", E, ", Q = ", vecQ);
wavenumber kother = tl::get_other_k(m_reso.E, m_dKFix/angs, m_bKiFix);
//tl::log_info("kother = ", t_real(kother*angs));
if(m_bKiFix)
{
m_tofreso.ki = m_reso.ki = m_dKFix / angs;
m_tofreso.kf = m_reso.kf = kother;
}
else
{
m_tofreso.ki = m_reso.ki = kother;
m_tofreso.kf = m_reso.kf = m_dKFix / angs;
}
m_reso.thetam = units::abs(tl::get_mono_twotheta(m_reso.ki, m_reso.mono_d, /*m_reso.dmono_sense>=0.*/1)*t_real(0.5));
m_reso.thetaa = units::abs(tl::get_mono_twotheta(m_reso.kf, m_reso.ana_d, /*m_reso.dana_sense>=0.*/1)*t_real(0.5));
m_tofreso.twotheta = m_reso.twotheta = units::abs(tl::get_sample_twotheta(m_reso.ki, m_reso.kf, m_reso.Q, 1));
//tl::log_info("thetam = ", tl::r2d(m_reso.thetam/rads));
//tl::log_info("thetaa = ", tl::r2d(m_reso.thetaa/rads));
//tl::log_info("twothetas = ", tl::r2d(m_reso.twotheta/rads));
m_tofreso.angle_ki_Q = m_reso.angle_ki_Q = tl::get_angle_ki_Q(m_reso.ki, m_reso.kf, m_reso.Q, /*m_reso.dsample_sense>=0.*/1);
m_tofreso.angle_kf_Q = m_reso.angle_kf_Q = tl::get_angle_kf_Q(m_reso.ki, m_reso.kf, m_reso.Q, /*m_reso.dsample_sense>=0.*/1);
//tl::log_info("kiQ = ", tl::r2d(m_reso.angle_ki_Q/rads));
//m_reso.angle_ki_Q = units::abs(m_reso.angle_ki_Q);
//m_reso.angle_kf_Q = units::abs(m_reso.angle_kf_Q);
if(m_foc != ResoFocus::FOC_UNCHANGED)
{
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_MONO_FLAT)) != 0) // flat mono
m_reso.bMonoIsCurvedH = m_reso.bMonoIsCurvedV = 0;
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_MONO_H)) != 0) // optimally curved mono (h)
m_reso.bMonoIsCurvedH = m_reso.bMonoIsOptimallyCurvedH = 1;
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_MONO_V)) != 0) // optimally curved mono (v)
m_reso.bMonoIsCurvedV = m_reso.bMonoIsOptimallyCurvedV = 1;
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_ANA_FLAT)) != 0) // flat ana
m_reso.bAnaIsCurvedH = m_reso.bAnaIsCurvedV = 0;
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_ANA_H)) != 0) // optimally curved ana (h)
m_reso.bAnaIsCurvedH = m_reso.bAnaIsOptimallyCurvedH = 1;
if((unsigned(m_foc) & unsigned(ResoFocus::FOC_ANA_V)) != 0) // optimally curved ana (v)
m_reso.bAnaIsCurvedV = m_reso.bAnaIsOptimallyCurvedV = 1;
//tl::log_info("Mono focus (h,v): ", m_reso.bMonoIsOptimallyCurvedH, ", ", m_reso.bMonoIsOptimallyCurvedV);
//tl::log_info("Ana focus (h,v): ", m_reso.bAnaIsOptimallyCurvedH, ", ", m_reso.bAnaIsOptimallyCurvedV);
// remove collimators
/*if(m_reso.bMonoIsCurvedH)
{
m_reso.coll_h_pre_mono = 99999. * rads;
m_reso.coll_h_pre_sample = 99999. * rads;
}
if(m_reso.bMonoIsCurvedV)
{
m_reso.coll_v_pre_mono = 99999. * rads;
m_reso.coll_v_pre_sample = 99999. * rads;
}
if(m_reso.bAnaIsCurvedH)
{
m_reso.coll_h_post_sample = 99999. * rads;
m_reso.coll_h_post_ana = 99999. * rads;
}
if(m_reso.bAnaIsCurvedV)
{
m_reso.coll_v_post_sample = 99999. * rads;
m_reso.coll_v_post_ana = 99999. * rads;
}*/
}
/*tl::log_info("thetam = ", m_reso.thetam);
tl::log_info("thetaa = ", m_reso.thetaa);
tl::log_info("2theta = ", m_reso.twotheta);*/
if(std::fabs(vecQ[2]) > s_dPlaneDistTolerance)
{
tl::log_err("Position Q = (", h, " ", k, " ", l, "),",
" E = ", E, " meV not in scattering plane.");
resores.strErr = "Not in scattering plane.";
resores.bOk = false;
return false;
}
vecQ.resize(2, true);
m_opts.dAngleQVec0 = -tl::vec_angle(vecQ);
//tl::log_info("angle Q vec0 = ", m_opts.dAngleQVec0);
//tl::log_info("calc r0: ", m_reso.bCalcR0);
for(ResoResults& resores_cur : m_res)
{
// if only one sample position is requested, don't randomise
if(m_res.size() > 1)
{
/*m_reso.pos_x = tl::rand_real(-t_real(m_reso.sample_w_q*0.5/cm),
t_real(m_reso.sample_w_q*0.5/cm)) * cm;
m_reso.pos_y = tl::rand_real(-t_real(m_reso.sample_w_perpq*0.5/cm),
t_real(m_reso.sample_w_perpq*0.5/cm)) * cm;
m_reso.pos_z = tl::rand_real(-t_real(m_reso.sample_h*0.5/cm),
t_real(m_reso.sample_h*0.5/cm)) * cm;*/
m_reso.pos_x = tl::rand_norm(t_real(0),
t_real(tl::get_FWHM2SIGMA<t_real>()*m_reso.sample_w_q/cm)) * cm;
m_reso.pos_y = tl::rand_norm(t_real(0),
t_real(tl::get_FWHM2SIGMA<t_real>()*m_reso.sample_w_perpq/cm)) * cm;
m_reso.pos_z = tl::rand_norm(t_real(0),
t_real(tl::get_FWHM2SIGMA<t_real>()*m_reso.sample_h/cm)) * cm;
}
// calculate resolution at (hkl) and E
if(m_algo == ResoAlgo::CN)
{
//tl::log_info("Algorithm: Cooper-Nathans (TAS)");
resores_cur = calc_cn(m_reso);
}
else if(m_algo == ResoAlgo::POP)
{
//tl::log_info("Algorithm: Popovici (TAS)");
resores_cur = calc_pop(m_reso);
}
else if(m_algo == ResoAlgo::ECK)
{
//tl::log_info("Algorithm: Eckold-Sobolev (TAS)");
resores_cur = calc_eck(m_reso);
}
else if(m_algo == ResoAlgo::VIOL)
{
//tl::log_info("Algorithm: Violini (TOF)");
m_reso.flags &= ~CALC_R0;
resores_cur = calc_viol(m_tofreso);
}
else
{
const char* pcErr = "Unknown algorithm selected.";
tl::log_err(pcErr);
resores_cur.strErr = pcErr;
resores_cur.bOk = false;
return false;
}
if(!resores_cur.bOk)
{
tl::log_err("Error calculating resolution: ", resores_cur.strErr);
tl::log_debug("R0: ", resores_cur.dR0);
tl::log_debug("res: ", resores_cur.reso);
}
}
return resores.bOk;
}
inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
void OsamaAI::performAttack(GameGridLayer* playerGrid)
{
//For test purposes
readTestValues();
//fillTheSetAndTest(this->pointsSet);
//this->pointsSet.clear();
//insertPointAndFillAdjacentPoints({5,5}, 4, ShipOrientation::vertical);
switch(state)
{
case State::searching:
{
Point2D<int> point; //{ rand()%10, rand() % 10};
if(reverseIt!=hitPoints.end()) {
point = {reverseIt->x, reverseIt->y };
reverseIt++;
} else
{
point = { rand()%10, rand()%10 };
}
//Osama do not hit a cells that are boundary to destroyed ships
while (doesIntersectsWithBoundary(point)) {
point = {rand()%10, rand()%10}; //generate new coordinates
}
if(!playerGrid->isCellTested(point.x, point.y)) {
CellState cellState = memoryMatrix[point.x][point.y] = playerGrid->hitCell(point.x, point.y);
pointsSet.insert(point);
switch(cellState)
{
case CellState::Hit:
{
if(point.x==0)
usedDirections.insert(Direction::left);
if(point.y==0)
usedDirections.insert(Direction::down);
if(point.x==9)
usedDirections.insert(Direction::right);
if(point.y==9)
usedDirections.insert(Direction::up);
m_originalShot = point;
shotsCount = 1;
shotsVector.push_back(point);
state = State::discoveringDirection; //transitionate to a new state
}
break;
case CellState::Destroyed:
//write ship coord and boundary into a set
//it's and 1 deck ship otherwise we should hit from another state
usedDirections.clear();
insertPointAndFillAdjacentPoints(point, 1, ShipOrientation::horizontal);
break;
default: pointsSet.insert(point);
}
}
}
break;
//We're moving to that state if we have discovered a ship
case State::discoveringDirection:
{
const Point2D<int> lastShot = shotsVector.back();
std::set<Direction> allDirections {Direction::up, Direction::down, Direction::left, Direction::right};
std::set<Direction> unusedDirections;
std::vector<Direction> vec1 (begin(usedDirections), end(usedDirections));
std::vector<Direction> vec2 (begin(allDirections ), end(allDirections ));
std::sort(begin(vec1), end(vec1), [](const Direction& d1, const Direction& d2)
{ return (static_cast<int>(d1) < static_cast<int>(d2)); });
std::sort(begin(vec2), end(vec2), [](const Direction& d1, const Direction& d2)
{ return (static_cast<int>(d1) < static_cast<int>(d2)); });
std::set_symmetric_difference(begin(vec1), end(vec1), begin(vec2),
end (vec2), inserter(unusedDirections,
unusedDirections.begin()));
std::vector<Direction> unusedDirectionsShuffled(begin(unusedDirections), end(unusedDirections));
std::srand(unsigned(std::time(0)));
std::random_shuffle(begin(unusedDirectionsShuffled), end(unusedDirectionsShuffled));
for(Direction direction: unusedDirectionsShuffled) {
Point2D<int> vector{0,0};
this->choosenDirection = direction;
switch(direction)
{
case Direction::up:
vector = {0,1};
break;
case Direction::down:
vector = {0,-1};
break;
case Direction::left:
vector = {-1,0};
break;
case Direction::right:
vector = {1,0};
break;
}
Point2D<int> newShot = lastShot + vector;
CellState cellState = CellState::Empty;
if(!doesIntersectsWithBoundary(newShot)) {
cellState = playerGrid->hitCell(newShot.x, newShot.y);
pointsSet.insert(newShot);
}
else
{
//change the direction and hit
continue;
}
if(cellState==CellState::Hit)
{
//right direction was choosen. continue to destroy ship in that direction
shotsCount++;
shotsVector.push_back(newShot);
state = State::destroyingShip;
break;
}
else if(cellState==CellState::Destroyed) {
//we destroyed a ship with that shot.
//store him in a matrix
//store it bounds
shotsCount++;
ShipOrientation shipOrientation;
if(direction==Direction::up||direction==Direction::down)
shipOrientation = ShipOrientation::vertical;
else
shipOrientation = ShipOrientation::horizontal;
insertPointAndFillAdjacentPoints(m_originalShot, shotsCount, shipOrientation);
state = State::searching;
shotsCount = 0;
usedDirections.clear();
break;
}
else if(cellState==CellState::Miss)
{
//store used direction so we won't hit there again
usedDirections.insert(direction);
break;
}
}
}
break;
case State::destroyingShip:
{
Point2D<int> vector{0,0};
const Point2D<int> lastShot = shotsVector.back();
switch(choosenDirection)
{
case Direction::up:
vector = {0,1};
break;
case Direction::down:
vector = {0,-1};
break;
case Direction::left:
vector = {-1,0};
break;
case Direction::right:
vector = {1,0};
break;
}
Point2D<int> newShot = lastShot + vector;
shotsVector.push_back(newShot);
if(isShotExceedsBoundary(newShot + vector))
{
state = State::discoveringDirection;
usedDirections.insert(choosenDirection);
shotsVector.push_back(m_originalShot);
}
auto cellState = playerGrid->hitCell(newShot.x, newShot.y);
switch(cellState)
{
case CellState::Miss:
usedDirections.insert(choosenDirection);
if(choosenDirection==Direction::up||choosenDirection==Direction::down)
{
usedDirections.insert(Direction::left);
usedDirections.insert(Direction::right);
} else {
usedDirections.insert(Direction::up);
usedDirections.insert(Direction::down);
}
shotsVector.push_back(m_originalShot);
pointsSet.insert(newShot);
state = State::discoveringDirection;
break;
case CellState::Hit:
shotsCount++;
pointsSet.insert(newShot);
break;
case CellState::Destroyed:
shotsCount++;
ShipOrientation shipOrientation;
if(choosenDirection==Direction::up||choosenDirection==Direction::down)
shipOrientation = ShipOrientation::vertical;
else
shipOrientation = ShipOrientation::horizontal;
insertPointAndFillAdjacentPoints(m_originalShot, shotsCount, shipOrientation);
shotsCount = 0;
usedDirections.clear();
state = State::searching; //Osama destroyed the ship
break;
default: break;
}
}
break;
}
}
inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
void CCommandProcessor::ParseCommand ( const char * const cmdBegin,
const uint64_t currentTime )
{
const char * const cmdEnd = SkipCharsNotInSet( cmdBegin, SPACE_AND_TAB );
assert( cmdBegin != cmdEnd );
const char * const paramBegin = SkipCharsInSet( cmdEnd, SPACE_AND_TAB );
bool extraParamsFound = false;
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_QUESTION_MARK, true, false, &extraParamsFound ) ||
IsCmd( cmdBegin, cmdEnd, CMDNAME_HELP, false, false, &extraParamsFound ) )
{
PrintStr( "This console is similar to the Bus Pirate console." EOL );
PrintStr( "Commands longer than 1 character are case insensitive." EOL );
PrintStr( "WARNING: If a command takes too long to run, the watchdog may reset the board." EOL );
PrintStr( "Commands are:" EOL );
Printf( " %s, %s: Show this help text." EOL, CMDNAME_QUESTION_MARK, CMDNAME_HELP );
Printf( " %s: Show version information." EOL, CMDNAME_I );
Printf( " %s: Test USB transfer speed." EOL, CMDNAME_USBSPEEDTEST );
Printf( " %s: Show JTAG pin status (read as inputs)." EOL, CMDNAME_JTAGPINS );
Printf( " %s: Test JTAG shift speed. WARNING: Do NOT connect any JTAG device." EOL, CMDNAME_JTAGSHIFTSPEEDTEST );
Printf( " %s: Exercises malloc()." EOL, CMDNAME_MALLOCTEST );
Printf( " %s: Exercises C++ exceptions." EOL, CMDNAME_CPP_EXCEPTION_TEST );
Printf( " %s: Shows memory usage." EOL, CMDNAME_MEMORY_USAGE );
Printf( " %s" EOL, CMDNAME_CPU_LOAD );
Printf( " %s" EOL, CMDNAME_UPTIME );
Printf( " %s" EOL, CMDNAME_RESET );
Printf( " %s" EOL, CMDNAME_RESET_CAUSE );
Printf( " %s <addr> <byte count>" EOL, CMDNAME_PRINT_MEMORY );
Printf( " %s <milliseconds>" EOL, CMDNAME_BUSY_WAIT );
Printf( " %s <command|protocol>" EOL, CMDNAME_SIMULATE_ERROR );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_I, true, false, &extraParamsFound ) )
{
#ifndef NDEBUG
const char buildType[] = "Debug build";
#else
const char buildType[] = "Release build";
#endif
Printf( "JtagDue %s" EOL, PACKAGE_VERSION );
Printf( "%s, compiler version %s" EOL, buildType, __VERSION__ );
Printf( "Watchdog %s" EOL, ENABLE_WDT ? "enabled" : "disabled" );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_RESET, false, false, &extraParamsFound ) )
{
// This message does not reach the other side, we would need to add some delay.
// UsbPrint( txBuffer, "Resetting the board..." EOL );
__disable_irq();
// Note that this message always goes to the serial port console,
// even if the user is connected over USB. It might be possible to send
// it over USB and then wait for the outgoing buffer to be empty.
SerialSyncWriteStr( "Resetting the board..." EOL );
SerialWaitForDataSent();
ResetBoard( ENABLE_WDT );
assert( false ); // We should never reach this point.
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_CPU_LOAD, false, false, &extraParamsFound ) )
{
if ( ENABLE_CPU_SLEEP )
PrintStr( "CPU load statistics not available." EOL );
else
DisplayCpuLoad();
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_UPTIME, false, false, &extraParamsFound ) )
{
char buffer[ CONVERT_TO_DEC_BUF_SIZE ];
Printf( "Uptime: %s seconds." EOL, convert_unsigned_to_dec_th( GetUptime() / 1000, buffer, ',' ) );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_RESET_CAUSE, false, false, &extraParamsFound ) )
{
DisplayResetCause();
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_PRINT_MEMORY, false, true, &extraParamsFound ) )
{
PrintMemory( paramBegin );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_BUSY_WAIT, false, true, &extraParamsFound ) )
{
BusyWait( paramBegin );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_USBSPEEDTEST, false, true, &extraParamsFound ) )
{
ProcessUsbSpeedTestCmd( paramBegin, currentTime );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_JTAGPINS, false, false, &extraParamsFound ) )
{
PrintJtagPinStatus();
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_JTAGSHIFTSPEEDTEST, false, false, &extraParamsFound ) )
{
if ( !IsNativeUsbPort() )
throw std::runtime_error( "This command is only available on the 'Native' USB port." );
// Fill the Rx buffer with some test data.
assert( m_rxBuffer != NULL );
m_rxBuffer->Reset();
for ( uint32_t i = 0; !m_rxBuffer->IsFull(); ++i )
{
m_rxBuffer->WriteElem( CUsbRxBuffer::ElemType( i ) );
}
// If the mode is set to MODE_HIZ, you cannot see the generated signal with the oscilloscope.
// Note also that the built-in pull-ups on the Atmel ATSAM3X8 are too weak (between 50 and 100 KOhm,
// yields too slow a rising time) to be of any use.
const bool oldPullUps = GetJtagPullups();
SetJtagPullups( false );
const JtagPinModeEnum oldMode = GetJtagPinMode();
SetJtagPinMode ( MODE_JTAG );
// Each JTAG transfer needs 2 bits in the Rx buffer, TMS and TDI,
// but produces only 1 bit, TDO.
const uint32_t jtagByteCount = m_rxBuffer->GetElemCount() / 2;
const uint16_t bitCount = jtagByteCount * 8;
// Shift all JTAG data through several times.
const uint64_t startTime = GetUptime();
const uint32_t iterCount = 50;
for ( uint32_t i = 0; i < iterCount; ++i )
{
// We hope that this will not clear the buffer contents.
assert( m_rxBuffer != NULL );
assert( m_txBuffer != NULL );
m_rxBuffer->Reset();
m_rxBuffer->CommitWrittenElements( jtagByteCount * 2 );
m_txBuffer->Reset();
ShiftJtagData( m_rxBuffer,
m_txBuffer,
bitCount );
assert( m_txBuffer->GetElemCount() == jtagByteCount );
}
const uint64_t finishTime = GetUptime();
const uint32_t elapsedTime = uint32_t( finishTime - startTime );
m_rxBuffer->Reset();
m_txBuffer->Reset();
const unsigned kBitsPerSec = unsigned( uint64_t(bitCount) * iterCount * 1000 / elapsedTime / 1024 );
SetJtagPinMode( oldMode );
SetJtagPullups( oldPullUps );
// I am getting 221 KiB/s with GCC 4.7.3 and optimisation level "-O3".
Printf( EOL "Finished JTAG shift speed test, throughput %u Kbits/s (%u KiB/s)." EOL,
kBitsPerSec, kBitsPerSec / 8 );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_MALLOCTEST, false, false, &extraParamsFound ) )
{
PrintStr( "Allocalling memory..." EOL );
volatile uint32_t * const volatile mallocTest = (volatile uint32_t *) malloc(123);
*mallocTest = 123;
PrintStr( "Releasing memory..." EOL );
free( const_cast< uint32_t * >( mallocTest ) );
PrintStr( "Test finished." EOL );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_CPP_EXCEPTION_TEST, false, false, &extraParamsFound ) )
{
try
{
PrintStr( "Throwing integer exception..." EOL );
throw 123;
PrintStr( "Throw did not work." EOL );
assert( false );
}
catch ( ... )
{
PrintStr( "Caught integer exception." EOL );
}
PrintStr( "Test finished." EOL );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_SIMULATE_ERROR, false, true, &extraParamsFound ) )
{
SimulateError( paramBegin );
return;
}
if ( IsCmd( cmdBegin, cmdEnd, CMDNAME_MEMORY_USAGE, false, false, &extraParamsFound ) )
{
const unsigned heapSize = unsigned( GetHeapEndAddr() - uintptr_t( &_end ) );
Printf( "Partitions: malloc heap: %u bytes, free: %u bytes, stack: %u bytes." EOL,
heapSize,
GetStackStartAddr() - GetHeapEndAddr(),
STACK_SIZE );
Printf( "Used stack (estimated): %u from %u bytes." EOL,
unsigned( GetStackSizeUsageEstimate() ),
STACK_SIZE );
const struct mallinfo mi = mallinfo();
const unsigned heapSizeAccordingToNewlib = unsigned( mi.arena );
Printf( "Heap: %u allocated from %u bytes." EOL,
unsigned( mi.uordblks ),
unsigned( mi.arena ) );
assert( heapSize == heapSizeAccordingToNewlib );
UNUSED_IN_RELEASE( heapSizeAccordingToNewlib );
return;
}
if ( extraParamsFound )
Printf( "Command \"%.*s\" does not take any parameters." EOL, cmdEnd - cmdBegin, cmdBegin );
else
Printf( "Unknown command \"%.*s\"." EOL, cmdEnd - cmdBegin, cmdBegin );
}
//}}}
//{{{
//------------------------------------------------------------------------
unsigned vcgen_contour::vertex(double* x, double* y)
{
unsigned cmd = path_cmd_line_to;
while(!is_stop(cmd))
{
switch(m_status)
{
case initial:
rewind(0);
case ready:
if(m_src_vertices.size() < 2 + unsigned(m_closed != 0))
{
cmd = path_cmd_stop;
break;
}
m_status = outline;
cmd = path_cmd_move_to;
m_src_vertex = 0;
m_out_vertex = 0;
case outline:
if(m_src_vertex >= m_src_vertices.size())
{
m_status = end_poly;
break;
}
m_stroker.calc_join(m_out_vertices,
m_src_vertices.prev(m_src_vertex),
m_src_vertices.curr(m_src_vertex),
m_src_vertices.next(m_src_vertex),
m_src_vertices.prev(m_src_vertex).dist,
m_src_vertices.curr(m_src_vertex).dist);
++m_src_vertex;
m_status = out_vertices;
m_out_vertex = 0;
case out_vertices:
if(m_out_vertex >= m_out_vertices.size())
{
m_status = outline;
}
else
{
const point_d& c = m_out_vertices[m_out_vertex++];
*x = c.x;
*y = c.y;
return cmd;
}
break;
case end_poly:
if(!m_closed) return path_cmd_stop;
m_status = stop;
return path_cmd_end_poly | path_flags_close | path_flags_ccw;
case stop:
return path_cmd_stop;
}
}
return cmd;
}
