void doThings(lua_State* L)
{
///////// create the meta table for character class /////////
luaL_newmetatable(L, "UnitMT");
lua_pushvalue(L, -1);
lua_setfield(L, -2, "__index");
lua_pushcfunction(L, function_unit_getDamage);
lua_setfield(L, -2, "getDamage");
lua_pushcfunction(L, function_unit_dealtDamage);
lua_setfield(L, -2, "dealtDamage");
lua_pushcfunction(L, function_unit_health);
lua_setfield(L, -2, "health");
lua_pop(L, 1);
//
//
//
//
// create new meta table for Character
luaL_newmetatable(L, "CharacterMT");
// set the meta table of the character meta table to be itself
// lua_pushvalue(L, -1);
// instead of referencing itself, we reference the unit mt as "parent"
luaL_getmetatable(L, "UnitMT");
lua_setfield(L, -2, "__index");
// pop the meta table from the stack
lua_pop(L, 1);
// create the 2 character
Character attacker("Attacker", 3, 10);
Unit defender(1, 20);
// print the state before the call
std::cout << "[C++] [Before damage] Attacker Hp : " << attacker.health << " Defender Hp : " << defender.health << std::endl;
std::cout << "[C++] Calling damage function from lua" << std::endl;
// manually do it here, to test the polymorphism
// put the function on the stack
lua_getglobal(L, "applyDamage");
// create a new user data on the stack, and assign the attacker pointer to it
putCharacter(L, attacker);
// create a new user data on the stack, and assign the defender pointer to it
putUnit(L, defender);
// call the function
lua_call(L, 2, 0);
// shouldn't have anything to pop
assert(lua_gettop(L) == 0);
// print the state after the call
std::cout << "[C++] [After damage] Attacker Hp : " << attacker.health << " Defender Hp : " << defender.health << std::endl;
lua_getglobal(L, "testcharacter");
putCharacter(L, attacker);
lua_call(L, 1, 0);
lua_getglobal(L, "testcharacter");
putUnit(L, defender);
lua_call(L, 1, 0);
}
void *attacker_t(void* data) //@ : pthread_run_joinable
//@ requires pthread_run_pre(attacker_t)(data, ?info);
//@ ensures false;
{
//@ open pthread_run_pre(attacker_t)(data, info);
struct ss_auth_args *args = (void*) data;
attacker(args->attacker, args->keypair);
return 0;
}
void run(const char *log_path, unsigned int text_max)
{
LogHelper log_helper(log_path);
AttackProgram attacker(text_max);
CryptoProgram crypto;
crypto.random_key();
attacker.attack(crypto);
attacker.last_round_key_recover();
attacker.secret_key_recover();
}
void Critter::MaybeReproduce(std::list<Critter *> &group) {
if (!attacker() && food >= 0.5 && ofRandomuf() < reproductivity() && group.size() < kMaxPopulation) {
area *= kChildScaleFactor;
food -= 0.5;
age = 0;
const ofVec2f epsilon = ofVec2f(0.1, 0.1);
Critter *critter = new Critter(player, 0, mass, area, position + epsilon, velocity);
group.push_back(critter);
}
const float cell_mortality = radius() <= kBreederSize ? mortality() : kWallMortality;
if (ofRandomuf() < cell_mortality * age * age * age) {
area = 0;
}
}
void *attacker_t(void* data) //@ : pthread_run_joinable
//@ requires pthread_run_pre(attacker_t)(data, ?info);
//@ ensures false;
{
while(true)
//@ invariant pthread_run_pre(attacker_t)(data, info);
{
//@ open pthread_run_pre(attacker_t)(data, info);
//@ close enc_then_hmac_proof_pred();
attacker();
//@ open enc_then_hmac_proof_pred();
//@ close pthread_run_pre(attacker_t)(data, info);
}
return 0;
}
void testFindStonesWithLiberties()
{
int boardWidth = 9;
BitBoard attacker(boardWidth);
attacker.putStone(8, 'a');
attacker.putStone(9, 'b');
BitBoard defender(boardWidth);
defender.putStone(9, 'a');
BitBoard* stonesWithLibs = complexOpps::findStonesWithLiberties(&attacker, &defender);
if (stonesWithLibs->bitCount()>0)
{
cout << "fail: testFindStonesWithLiberties" << endl;
}
else
{
cout << "pass: testFindStonesWithLiberties" << endl;
}
delete stonesWithLibs;
}
void testFindLibertiesAdjacentStones()
{
int boardWidth = 9;
BitBoard attacker(boardWidth);
attacker.putStone(8, 'a');
attacker.putStone(9, 'b');
BitBoard defender(boardWidth);
defender.putStone(9, 'a');
BitBoard* libsAdjStones = complexOpps::findLibertiesAdjacentStones(&defender, &attacker);
if (libsAdjStones->bitCount()>0)
{
cout << "fail: testFindLibertiesAdjacentStones" << endl;
}
else
{
cout << "pass: testFindLibertiesAdjacentStones" << endl;
}
delete libsAdjStones;
}
// Write your strategy here in game function.
// You can also make new functions and call them from game function.
void game(BeliefState *state)
{
//curTeamState->Enter(curPlayerStates);
curTeamState->Act(state, curPlayerStates);
int i;
for (i = 1; i < 3; ++i) {
//std::string s = curPlayerStates[i]->StateName();
//print("%s", s);
curPlayerStates[i]->StateName();
PlayerSt * newPlSt = curPlayerStates[i]->Act(state);
if (newPlSt != NULL) {
//changePlayerState(curPlayerStates, i, newPlSt);
curPlayerStates[i] = newPlSt;
curPlayerStates[i]->Act(state);
}
}
return;
//storePositions(state);
//attacker(state,2);
for (int i = 0; i < 5; i++) {
//state->homeAngle[i] = acos(state->homeVel[i].dot(Vector2D<float>(0, 1)) / state->homeVel[i].abs());
}
if (state->ballPos.x >= -100) {
if (Vec2D::dist(state->homePos[2], state->ballPos) < Vec2D::dist(state->homePos[1], state->ballPos)) {
attacker_id = 2;
supporter_id = 1;
}
else {
attacker_id = 1;
supporter_id = 2;
}
attacker(state, attacker_id);
attacksupporter(state, supporter_id);
}
else {
if (Vec2D::dist(state->homePos[2], state->ballPos) < Vec2D::dist(state->homePos[1], state->ballPos)) {
defender(state, 1);
attacker(state, 2);
}
else {
defender(state, 2);
attacker(state, 1);
}
}
goalkeeper(state,0);
Vec2D bp = state->ballPos;
/* if (state->pr_balInOurCorner) {
int closestBotId = state->ourBotNearestToBall;
GoToPoint(1, state, state->homePos[0], 0, true, true);
}
if (Vec2D::dist(prevPos[2], state->homePos[2]) < 2) {
Vec2D newPos = state->homePos[2];
newPos.x += rand() % 5;
newPos.y += rand() % 5;
GoToPoint(2, state, newPos, 0, true, true);
}
if (Vec2D::dist(prevPos[1], state->homePos[1]) < 2) {
Vec2D newPos = state->homePos[1];
newPos.x += rand() % 5;
newPos.y += rand() % 5;
GoToPoint(1, state, newPos, 0, true, true);
}
*/
}
void symbolic_attacker(int attacker_id, struct keypair* keypair)
/*@ requires [?f]world(?pub, ?key_clsfy) &*&
true == bad(attacker_id) &*&
principal(attacker_id, ?count) &*&
keypair(keypair, attacker_id, ?id, ?info, pub); @*/
//@ ensures false;
{
//@ retreive_proof_obligations();
for (;;)
/*@ invariant [f]world(pub, key_clsfy) &*&
proof_obligations(pub) &*&
principal(attacker_id, _) &*&
keypair(keypair, attacker_id, id, info, pub); @*/
{
struct network_status *net_stat = 0;
int net_choise = random_int_();
int port = random_int_();
if (net_choise % 2 == 0)
net_stat = network_bind_and_accept(port % 65536);
else
net_stat = network_connect("localhost", port % 65536);
{
int action = random_int_();
int *counter;
switch (action % 13)
{
case 0:
//@ open [f]world(pub, key_clsfy);
//@ assert [_]is_key_classifier(_, pub, key_clsfy);
//@ retreive_public_invariant_constraints(key_clsfy);
//@ duplicate_lemma_function_pointer_chunk(key_classifier);
/*@ {
lemma void public_key_classifier(cryptogram key, int p, int c,
bool symmetric)
requires polarssl_proof_pred(pub, key_clsfy)() &*&
[_]polarssl_pub(pub)(key) &*&
symmetric ?
key == cg_symmetric_key(p, c)
:
key == cg_private_key(p, c);
ensures polarssl_proof_pred(pub, key_clsfy)() &*&
col || true == key_clsfy(p, c, symmetric);
{
open [_]polarssl_pub(pub)(key);
item k;
if (symmetric)
k = symmetric_key_item(p, c);
else
k = private_key_item(p, c);
open polarssl_proof_pred(pub, key_clsfy)();
assert is_key_classifier(?proof, pub, key_clsfy);
proof(k, p, c, symmetric);
close polarssl_proof_pred(pub, key_clsfy)();
}
produce_lemma_function_pointer_chunk(public_key_classifier) :
public_key_classifier(polarssl_pub(pub), key_clsfy,
polarssl_proof_pred(pub, key_clsfy))
(key__, p__, c__, sym__)
{ call(); }
{duplicate_lemma_function_pointer_chunk(public_key_classifier);};
}
@*/
//@ close polarssl_proof_pred(pub, key_clsfy)();
attacker();
//@ open polarssl_proof_pred(pub, key_clsfy)();
//@ close [f]world(pub, key_clsfy);
//@ leak public_invariant_constraints(_, _);
//@ leak is_public_key_classifier(_, _, _, _);
//@ leak is_key_classifier(_, _, _);
break;
case 1:
// Anyone can publish arbitrary data items...
send_data(net_stat);
break;
case 2:
// Anyone can create pairs of public items...
send_pair_composed(net_stat);
break;
case 3:
// Anyone can deconstruct a public pair...
send_pair_decomposed(net_stat);
break;
case 4:
// Bad principals can publish generated nonce items...
send_nonce(net_stat);
break;
case 5:
// Bad principals can increment public nonces...
increment_and_send_nonce(net_stat);
break;
case 6:
// Bad principals can leak their keys...
send_keys(net_stat, keypair);
break;
case 7:
// Anyone can hmac public payload with public key
send_hmac(net_stat, keypair);
break;
case 8:
// Anyone can symmteric encrypt public payload with public key
send_symmetric_encrypted(net_stat, keypair);
break;
case 9:
// Anyone can symmteric decrypt message with public key
send_symmetric_decrypted(net_stat, keypair);
break;
case 10:
// Anyone can asymmteric encrypt public payload with public key
send_asymmetric_encrypted(net_stat, keypair);
break;
case 11:
// Anyone can asymmteric decrypt message with public key
send_asymmetric_decrypted(net_stat, keypair);
break;
case 12:
// Anyone can asymmteric sign public payload with public key
send_asymmetric_signature(net_stat, keypair);
}
}
network_disconnect(net_stat);
}
//@ leak proof_obligations(pub);
}
