void WorldLogic::restartGame(Logic &l)
{
for (const std::shared_ptr<GameObject> &obj: l.game_model()->objects()) {
if (typeid(obj) != typeid(model::Explosion)) {
obj->alive() = false;
}
}
add_box_interval_timer = 0.f;
next_powerup_timer = NAN; // batman
box_count = 0;
_model->alive() = true;
_model->playerPoints() = 0;
_model->remainingLives() = 5;
l.game_model()->gameSpeed() = 1.f;
l.game_model()->stickyWallTimer() = 0.f;
std::shared_ptr<Paddle> user_paddle(new Paddle("PlayerPaddle"));
user_paddle->size() = vec3_type(10.f, 2.5f, 10.f);
user_paddle->position() = vec3_type(0.f, -_model->getWorldHalfHeight() + user_paddle->size().y() * 2.f, 0.f);
user_paddle->maxPosition() = vec3_type(_model->getWorldHalfWidth() - user_paddle->size().x() / 2.f, _model->getWorldHalfHeight(), HUGE_VALF);
l.game_model()->addGameObject(user_paddle);
_shallRestartTheGame = false;
_model->gameRestarted() = true;
}
Logic& Logic::getInstance()
{
static Logic inst;
if (!inst._initialized)
inst.setInitialCoords();
return inst;
}
void Army::Move( Logic& l, float delta_time, int& i )
{
if( to == final_to )
{
for( int j(0); j < l.GetArmies().size(); j++ )
{
Army& a( l.GetArmyByIndex(j) );
if( a.used && i != j && x == a.x && y == a.y )
{
soldiers += a.soldiers;
carts += a.carts;
rectangles[ (int)Type::Army ].erase( a.rectangle );
l.GetArmies().erase( j );
break;
}
}
from = to;
state = Stationary;
}
else
{
from = to;
to = l.CalculatePathTo( *this, final_to );
}
}
void Farm::Update( Logic& l, float delta_time )
{
if( !used )
return;
float efficency = population / population_needed;
if( efficency > 1.f )
efficency = 1.f;
food += food_production * delta_time * efficency;
if( food > food_max )
food = food_max;
// Move extra population to city if possible
if( population > population_needed )
{
int i = l.GetCityIndex( point );
if( i != -1 )
{
City& c( l.GetCityByIndex( i ) );
c.population += population - population_needed;
population = population_needed;
}
}
l.PopulationCalculations( food, population, hunger, delta_time );
}
void onWrite (beast::PropertyStream::Map& map)
{
Context::Scope scope (m_context);
map ["trusted"] = m_logic.getChosenSize();
{
beast::PropertyStream::Set items ("sources", map);
for (auto const& entry : m_logic.getSources())
{
items.add (entry.source->to_string());
}
}
{
beast::PropertyStream::Set items ("validators", map);
for (auto const& entry : m_logic.getValidators())
{
RipplePublicKey const& publicKey (entry.first);
Validator const& validator (entry.second);
beast::PropertyStream::Map item (items);
item["public_key"] = publicKey.to_string();
validator.count().onWrite (item);
}
}
}
/***********************************************************************
Truth Table Generating function
It takes the type of Family Type and number of inputs as input
***********************************************************************/
void LogicProcessor::ShowTruthTable(LogicType aLogicType, int aNumInputs){
Logic* pLogic = CreateLogic(aLogicType, aNumInputs);
bool** inputTable = GenerateInputTable(aNumInputs);
int rowSize = int(pow(2, aNumInputs));
int i=0;
//For each combination of input
for (;i<rowSize;i++) {
//Display all input in this combination
for (int j=0; j<aNumInputs; j++) {
DisplayValue(inputTable[i][j]);
}
//Process these inputs for this Logic
bool output = pLogic->Process(inputTable[i]);
cout<<"--> ";
//Display output
DisplayValue(output);
cout<<endl;
}
delete pLogic;
//Destruct the Input Table
for (i=0;i<rowSize;i++){
delete []inputTable[i];
}
}
int main(int argument_count, char** argument_vars) {
//runTest(argument_count, argument_vars) ;
Logic driver ;
driver.logicMain() ;
return 0 ;
}
void TestLogicUserUpdate()
{
static Logic logic;
User user;
user.name = "admin";
user.password = "******";
user.authority = 1;
logic.userUpdate(user);
}
void LogicCollection::Load( std::istream& p_stream, entityid p_id )
{
std::string temp;
p_stream >> temp; // chew up the "[LOGICS]"
p_stream >> temp; // load in the first logic name
// loop while there are logic modules available
while( temp != "[/LOGICS]" )
{
Add( temp, p_id );
Logic* c = Get( temp );
c->Load( p_stream );
p_stream >> temp; // try reading next logic name
}
}
void
on_endpoints (Slot::ptr const& slot,
Endpoints const& endpoints) override
{
SlotImp::ptr impl (std::dynamic_pointer_cast <SlotImp> (slot));
m_logic.on_endpoints (impl, endpoints);
}
Result
activate (Slot::ptr const& slot,
RipplePublicKey const& key, bool cluster) override
{
SlotImp::ptr impl (std::dynamic_pointer_cast <SlotImp> (slot));
return m_logic.activate (impl, key, cluster);
}
bool
onConnected (Slot::ptr const& slot,
beast::IP::Endpoint const& local_endpoint) override
{
SlotImp::ptr impl (std::dynamic_pointer_cast <SlotImp> (slot));
return m_logic.onConnected (impl, local_endpoint);
}
void onStop ()
{
m_logic.stop ();
m_queue.dispatch (m_context.wrap (std::bind (
&Thread::signalThreadShouldExit, this)));
}
Slot::ptr
new_inbound_slot (
beast::IP::Endpoint const& local_endpoint,
beast::IP::Endpoint const& remote_endpoint) override
{
return m_logic.new_inbound_slot (local_endpoint, remote_endpoint);
}
void TestLogicFactoryInsert(Logic& logic)
{
Factory f;
f.name = "饮料厂";
f.addr = "饮料路饮料厂";
f.email = "*****@*****.**";
logic.factoryInsert(f);
}
void run ()
{
do
{
m_logic.periodicActivity();
wait (1000);
}
while (! threadShouldExit ());
}
void init ()
{
beast::Error error (m_store.open (m_databaseFile));
if (! error)
{
m_logic.load ();
}
}
void onStop()
{
boost::system::error_code ec;
timer_.cancel(ec);
logic_.stop();
exec_.async_wait([this]() { stopped(); });
}
void
close()
{
if (work_)
{
work_ = boost::none;
checker_.stop();
m_logic.stop();
}
}
void
onPrepare ()
{
beast::Error error (m_store.open (m_databaseFile));
if (error)
m_journal.fatal <<
"Failed to open '" << m_databaseFile.getFullPathName() << "'";
if (! error)
m_logic.load ();
}
void run ()
{
beast::setCurrentThreadName ("Resource::Manager");
for(;;)
{
logic_.periodicActivity();
std::unique_lock<std::mutex> lock(mutex_);
cond_.wait_for(lock, std::chrono::seconds(1));
if (stop_)
break;
}
}
// with activate
void
test_backoff2()
{
auto const seconds = 10000;
testcase("backoff 2");
TestStore store;
TestChecker checker;
TestStopwatch clock;
Logic<TestChecker> logic (clock, store, checker, beast::Journal{});
logic.addFixedPeer ("test",
beast::IP::Endpoint::from_string("65.0.0.1:5"));
{
Config c;
c.autoConnect = false;
c.listeningPort = 1024;
logic.config(c);
}
std::size_t n = 0;
std::array<std::uint8_t, 33> key;
key.fill(0);
for (std::size_t i = 0; i < seconds; ++i)
{
auto const list = logic.autoconnect();
if (! list.empty())
{
expect (list.size() == 1);
auto const slot = logic.new_outbound_slot(list.front());
if (! expect (logic.onConnected(slot,
beast::IP::Endpoint::from_string("65.0.0.2:5"))))
return;
std::string s = ".";
RipplePublicKey pk (key.begin(), key.end());
if (! expect (logic.activate(slot, pk, false) ==
PeerFinder::Result::success, "activate"))
return;
logic.on_closed(slot);
++n;
}
clock.advance(std::chrono::seconds(1));
logic.once_per_second();
}
// No more often than once per minute
expect (n <= (seconds+59)/60, "backoff");
}
void Army::Transport( Logic& l, float delta_time )
{
if( to == final_to )
{
int i = l.GetCityIndex( to );
if( to == transporting_to )
{
if( i == -1 )
throw std::string("Must transport to a city");
City& c( l.GetCityByIndex(i) );
c.food_contained += food_stored;
food_stored = 0;
}
else if( to == transporting_from )
{
if( i != -1 )
{
City& c( l.GetCityByIndex(i) );
if( hunger > 0 )
{
c.food_contained -= hunger;
hunger = 0;
}
food_stored = storage_capacity;
c.food_contained -= food_stored;
}
else
{
int j = l.GetFarmIndex( to );
if( j == -1 )
throw std::string("Must transport from a city or farm");
Farm& f( l.GetFarmByIndex( j ) );
if( hunger > 0 )
{
f.food -= hunger;
hunger = 0;
}
food_stored = storage_capacity;
f.food -= food_stored;
}
}
final_to = from;
from = to;
to = l.CalculatePathTo( *this, final_to );
}
else
{
from = to;
to = l.CalculatePathTo( *this, final_to );
}
}
int main() {
// add. step <3/3>
dynamic_add(MyLogic);
DynamicBase *obj;
// get, class. of course we can get from where didn't know Mylogic class except its base class.
// @see line:18
dynamic_get(std::string("Mylogic"), obj);
if (obj) {
// here is the point, we just know the base class. Logic.
Logic *lc = (Logic*)obj;
lc->do_something(); // here, -----> will call really_do_something() in Mylogic class, where we didn't know the class name. MyLogic.
}
// very simple, have fun.
reutnr 0;
}
void BuildTestData()
{
static Logic logic;
QFile file("buildTestData.txt");
file.open(QFile::ReadOnly);
QTextStream ts(&file);
while( !ts.atEnd() )
{
QString name;
int32 count;
ts>>name>>count;
printf("%s %d\n", name.toStdString().c_str(), count);
if( name == "user" )
{
User user;
for( int32 i = 0; i < count; ++i )
{
ts>>user.name>>user.password>>user.authority;
//printf("user\n");
logic.userInsert(user);
}
}
else if( name == "factory" )
void TestLogicProductInsert(Logic& logic)
{
Product p;
p.name = "手机";
p.type = "重武器";
p.count= 20;
p.MF_id = 0;
p.price_buy = 10000;
p.price_nw = 100010;
p.price_ww = 200000;
p.date = "2011/5/29";
p.fee_other = 0;
logic.productInsert(p);
}
void Quarry::Update( Logic& l, float delta_time )
{
if( !used )
return;
float efficency = population / population_needed;
if( efficency > 1.f )
efficency = 1.f;
l.PopulationCalculations( food_contained, population, hunger, delta_time );
if( stone_contained >= stone_storage )
{
stone_contained = stone_storage;
return;
}
// Reduce mountain maeby change to require more effort to extract more stone
auto& v( height_map.square_contained );
auto i = std::find( v.begin(), v.end(), Resource::Stone );
auto closest = i;
auto& r( rectangles[ (int)Type::Quarry ][rectangle] );
auto size = 5; // TODO: Move value to a config file
auto closest_length = size;
while(true)
{
if( i == v.end() )
{
if( closest_length != size )
{
auto& resource( height_map.square_amount[ closest - v.begin() ] );
stone_contained += stone_production * delta_time * efficency;
resource -= stone_production * delta_time * efficency;
if( resource <= 0 )
height_map.Remove( closest - v.begin() );
}
break;
}
auto s = sqrt( pow( r.x - height_map.PosX( i - v.begin() ), 2 ) + pow( r.y - height_map.PosY( i - v.begin() ), 2 ) ); // TODO: Mabye remove v.begin()
if( s < closest_length )
{
closest_length = s;
closest = i;
}
i = std::find( ++i, v.end(), Resource::Stone );
}
}
void WorldLogic::addBoxToGame(Logic &l)
{
std::uniform_real_distribution<scalar_type> size_exp_dist(1.7f, 3.4f);
scalar_type size = exp2(size_exp_dist(rng));
vec3_type max_pos(_model->getWorldHalfWidth() - size / 2.f, _model->getWorldHalfHeight() - size / 2.f, HUGE_VALF);
std::uniform_real_distribution<scalar_type> x_dist(-max_pos.x(), max_pos.x());
scalar_type x = x_dist(rng);
std::shared_ptr<Box> box(new Box("Box", !_model->remainingLives()));
box->size() = size;
box->position() = vec3_type(x, 0.f, 0.f);
box->maxPosition() = max_pos;
l.game_model()->addGameObject(box);
box_count++;
}
void
onTimer (boost::system::error_code ec)
{
if (ec)
{
if (ec != boost::asio::error::operation_aborted)
journal_.error <<
"onTimer: " << ec.message();
return;
}
logic_.onTimer();
timer_.expires_from_now(std::chrono::seconds(1), ec);
timer_.async_wait(strand_.wrap(exec_.wrap(
std::bind(&ManagerImp::onTimer, this,
beast::asio::placeholders::error))));
}
void onStop ()
{
#if RIPPLE_USE_VALIDATORS
m_journal.info << "Validators stopping";
#endif
m_logic.stop ();
if (this->Thread::isThreadRunning())
{
m_journal.debug << "Signaling thread exit";
m_queue.dispatch (m_context.wrap (bind (
&Thread::signalThreadShouldExit, this)));
}
else
{
stopped();
}
}
