{

commands.push_back(PluginCommand("nyan","NYAN CAT INVASION!",kittens));

commands.push_back(PluginCommand("ktimer","Measure time between game updates and console lag.",ktimer));

commands.push_back(PluginCommand("trackmenu","Track menu ID changes (toggle).",trackmenu));

commands.push_back(PluginCommand("trackpos","Track mouse and designation coords (toggle).",trackpos));

commands.push_back(PluginCommand("trackstate","Track world and map state (toggle).",trackstate));

commands.push_back(PluginCommand("colormods","Dump colormod vectors.",colormods));

commands.push_back(PluginCommand("sharedsignal","Test Signal with signal_shared_tag",sharedsignal));

return CR_OK;

{

shutdown_flag = true;

while(!final_flag)

{

Core::getInstance().getConsole().msleep(60);

}

return CR_OK;

{

if(!statetrack)

return CR_OK;

switch (event) {

case SC_MAP_LOADED:

out << "Map loaded" << endl;

break;

case SC_MAP_UNLOADED:

out << "Map unloaded" << endl;

break;

case SC_WORLD_LOADED:

out << "World loaded" << endl;

break;

case SC_WORLD_UNLOADED:

out << "World unloaded" << endl;

break;

case SC_VIEWSCREEN_CHANGED:

out << "Screen changed" << endl;

break;

default:

out << "Something else is happening, nobody knows what..." << endl;

break;

}

return CR_OK;

{

if(timering)

{

uint64_t time2 = GetTimeMs64();

uint64_t delta = time2-timeLast;

timeLast = time2;

out.print("Time delta = {} ms\n", int(delta));

}

if(trackmenu_flg)

{

if (last_menu != plotinfo->main.mode)

{

last_menu = plotinfo->main.mode;

out.print("Menu: {}\n", ENUM_AS_STR(last_menu));

}

}

if(trackpos_flg)

{

int32_t desig_x, desig_y, desig_z;

Gui::getDesignationCoords(desig_x,desig_y,desig_z);

if(desig_x != last_designation[0] || desig_y != last_designation[1] || desig_z != last_designation[2])

{

last_designation[0] = desig_x;

last_designation[1] = desig_y;

last_designation[2] = desig_z;

out.print("Designation: {} {} {}\n", desig_x, desig_y, desig_z);

}

df::coord mousePos = Gui::getMousePos();

if(mousePos.x != last_mouse[0] || mousePos.y != last_mouse[1])

{

last_mouse[0] = mousePos.x;

last_mouse[1] = mousePos.y;

out.print("Mouse: {} {}\n", mousePos.x, mousePos.y);

}

}

return CR_OK;

{

bool is_running = trackmenu_flg.exchange(false);

if(is_running)

{

return CR_OK;

}

else

{

is_enabled = true;

last_menu = plotinfo->main.mode;

out.print("Menu: {}\n", ENUM_AS_STR(last_menu));

trackmenu_flg = true;

return CR_OK;

}

{

trackpos_flg.fetch_xor(1);

is_enabled = true;

return CR_OK;

{

statetrack.fetch_xor(1);

return CR_OK;

{

auto & vec = world->raws.creatures.alphabetic;

for(df::creature_raw* rawlion : vec)

{

df::caste_raw * caste = rawlion->caste[0];

out.print("{}\nCaste addr {}\n",rawlion->creature_id, static_cast<void*>(&caste->color_modifiers));

for(size_t j = 0; j < caste->color_modifiers.size();j++)

{

out.print("mod {}: {}\n", j, static_cast<void*>(caste->color_modifiers[j]));

}

}

return CR_OK;

{

bool is_running = timering.exchange(false);

if(is_running)

{

return CR_OK;

}

uint64_t timestart = GetTimeMs64();

{

uint64_t timeend = GetTimeMs64();

timeLast = timeend;

timering = true;

out.print("Time to suspend = {} ms\n", int(timeend - timestart));

}

is_enabled = true;

return CR_OK;

~ClearMem()

{

memset(reinterpret_cast<void*>(this), 0xDE, sizeof(Derived));

}

using Sig = Signal<void(uint32_t), signal_shared_tag>;

std::array<Sig::Connection,4> con;

Sig signal;

weak other;

Sig::weak_ptr other_sig;

color_ostream *out;

int id;

uint32_t count;

uint32_t caller;

alignas(64) std::atomic<uint32_t> callee;

Connected() = default;

Connected(int id) :

Connected{}

{

this->id = id;

}

void connect(color_ostream& o, shared& b, size_t pos, uint32_t c)

{

out = &o;

count = c*2;

other = b;

other_sig = b->signal.weak_from_this();

// Externally synchronized object destruction is only safe to this

// connect.

con[pos] = b->signal.connect(

[this](uint32_t) {

uint32_t old = callee.fetch_add(1);

assert(old != 0xDEDEDEDE); (void)old;

std::this_thread::sleep_for(delay);

assert(callee != 0xDEDEDEDE);

});

// Shared object managed object with possibility of destruction while

// other threads calling emit must pass the shared_ptr to connect.

Connected *bptr = b.get();

b->con[pos] = signal.connect(b,

[bptr](int) {

uint32_t old = bptr->callee.fetch_add(1);

assert(old != 0xDEDEDEDE); (void)old;

std::this_thread::sleep_for(delay);

assert(bptr->callee != 0xDEDEDEDE);

});

}

void reconnect(size_t pos) {

auto b = other.lock();

if (!b)

return;

// Not required to use Sig::lock because other holds strong reference to

// Signal. But this just shows how weak_ref could be used.

auto sig = Sig::lock(other_sig);

if (!sig)

return;

con[pos] = sig->connect(b,

[this](uint32_t) {

uint32_t old = callee.fetch_add(1);

assert(old != 0xDEDEDEDE); (void)old;

std::this_thread::sleep_for(delay);

assert(callee != 0xDEDEDEDE);

});

}

void connect(color_ostream& o, shared& a, shared& b,size_t pos, uint32_t c)

{

out = &o;

count = c;

con[pos] = b->signal.connect(a,

[this](uint32_t) {

uint32_t old = callee.fetch_add(1);

assert(old != 0xDEDEDEDE); (void)old;

std::this_thread::sleep_for(delay);

assert(callee != 0xDEDEDEDE);

});

}

Connected* operator->() noexcept

{

return this;

}

~Connected() {

INFO(command,*out).print("Connected {} had {} count. "

"It was caller {} times. "

"It was callee {} times.\n",

id, count, caller, callee.load());

}

{

using rng_t = std::linear_congruential_engine<uint32_t, 747796405U, 2891336453U, 0>;

rng_t rng(std::random_device{}());

size_t count = 10;

if (0 < parameters.size()) {

std::stringstream ss(parameters[0]);

ss >> count;

DEBUG(command, out) << "Parsed " << count

<< " from paramters[0] '" << parameters[0] << '\'' << std::endl;

}

std::uniform_int_distribution<uint32_t> dis(4096,8192);

out << "Running signal_shared_tag destruction test "

<< count << " times" << std::endl;

for (size_t nr = 0; nr < count; ++nr) {

std::array<std::thread,4> t{};

// Make an object which destruction is protected by std::thread::join()

Connected external{static_cast<int>(t.size())};

TRACE(command, out) << "begin " << std::endl;

{

int id = 0;

// Make objects that are automatically protected using weak_ptr

// references that are promoted to shared_ptr when Signal is

// accessed.

std::array<shared,4> c = {

std::make_shared<Connected>(id++),

std::make_shared<Connected>(id++),

std::make_shared<Connected>(id++),

std::make_shared<Connected>(id++),

};

assert(t.size() == c.size());

for (unsigned i = 1; i < c.size(); ++i) {

c[0]->connect(out, c[0], c[i], i - 1, dis(rng));

c[i]->connect(out, c[i], c[0], 0, dis(rng));

}

external.connect(out, c[1], 1, dis(rng));

auto thr = [&out](shared c) {

TRACE(command, out) << "Thread " << c->id << " started." << std::endl;

weak ref = c;

for (;c->caller < c->count; ++c->caller) {

c->signal(std::move(c->caller));

}

TRACE(command, out) << "Thread " << c->id << " resets shared." << std::endl;

c.reset();

while((c = ref.lock())) {

++c->caller;

c->signal(std::move(c->caller));

c.reset();

std::this_thread::sleep_for(delay*25);

}

};

for (unsigned i = 0; i < c.size(); ++i) {

TRACE(command, out) << "start thread " << i << std::endl;

t[i] = std::thread{thr, c[i]};

}

}

TRACE(command, out) << "running " << std::endl;

for (;external->caller < external->count; ++external->caller) {

external->signal(std::move(external->caller));

external->reconnect(1);

}

TRACE(command, out) << "join " << std::endl;

for (unsigned i = 0; i < t.size(); ++i)

t[i].join();

}

return CR_OK;

{

if (parameters.size() >= 1)

{

if (parameters[0] == "stop")

{

shutdown_flag = true;

while(!final_flag)

{

Core::getInstance().getConsole().msleep(60);

}

shutdown_flag = false;

return CR_OK;

}

}

final_flag = false;

if (!out.is_console())

return CR_FAILURE;

Console &con = static_cast<Console&>(out);

// http://evilzone.org/creative-arts/nyan-cat-ascii/

const char * nyan []=

{

"NYAN NYAN NYAN NYAN NYAN NYAN NYAN",

"+ o + o ",

" + o + +",

"o +",

" o + + +",

"+ o o + o",

"-_-_-_-_-_-_-_,------, o ",

"_-_-_-_-_-_-_-| /\\_/\\ ",

"-_-_-_-_-_-_-~|__( ^ .^) + + ",

"_-_-_-_-_-_-_-\"\" \"\" ",

"+ o o + o",

" + +",

"o o o o +",

" o +",

"+ + o o + ",

"NYAN NYAN NYAN NYAN NYAN NYAN NYAN",

0

};

const char VARIABLE_IS_NOT_USED * kittenz1 []=

{

" ____",

" (. \\",

" \\ | ",

" \\ |___(\\--/)",

" __/ ( . . )",

" \"'._. '-.O.'",

" '-. \\ \"|\\",

" '.,,/'.,,mrf",

0

};

con.cursor(false);

con.clear();

Console::color_value color = COLOR_BLUE;

while(1)

{

if(shutdown_flag || !con.isInited())

{

final_flag = true;

con.reset_color();

con << std::endl << "NYAN!" << std::endl << std::flush;

return CR_OK;

}

con.color(color);

int index = 0;

const char * kit = nyan[index];

con.gotoxy(1,1);

//con << "Your DF is now full of kittens!" << std::endl;

while (kit != 0)

{

con.gotoxy(1,1+index);

con << kit << std::endl;

index++;

kit = nyan[index];

}

con.flush();

con.msleep(60);

color = Console::color_value(int(color) + 1);

if(color > COLOR_MAX)

color = COLOR_BLUE;

}