You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

331 lines
7.9 KiB

#include "jsmn.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <set>
#include <vector>
#include <cassert>
using std::vector;
// Parsování JSONu
static int jsoneq(const char *json, jsmntok_t *tok, const char *s) {
if (tok->type == JSMN_STRING && (int)strlen(s) == tok->end - tok->start &&
strncmp(json + tok->start, s, tok->end - tok->start) == 0) {
return 0;
}
return -1;
}
// Třídy reprezentující hru
enum Direction
{
STAY = -1,
UP = 0,
LEFT = 1,
DOWN = 2,
RIGHT = 3,
};
struct Team;
struct Member;
struct Field;
struct Team
{
int id;
bool is_me;
Field* home;
vector<Field*> occupied;
vector<Field*> protected_fields;
vector<Member*> members;
Team(int _id, bool _is_me)
{
id = id;
is_me = _is_me;
}
};
struct Member
{
Field * field;
Team * team;
int id;
Direction action = STAY;
Member(Field *_field)
{
field = _field;
}
};
struct Field
{
int i,j;
bool hill;
Team* home_for_team = NULL;
Team* occupied_by_team = NULL;
Team* protected_for_team = NULL;
vector<Member*> members;
Field(int _i, int _j)
{
i = _i;
j = _j;
}
};
// Celý stav hry včetně parsování a vypisování
struct State
{
// Dealokace paměti není implementována, protože předpokládáme, že program
// poběží jen krátce a po ukončení všechna paměť automaticky zanikne.
vector<Team*> teams;
vector<vector<Field*>> world;
Team * my_team;
int round_number;
int time_to_response;
int js_skip(jsmntok_t* t, int i)
{
int s = t[i].size;
i++;
for(int j=0; j<s; j++)
i = js_skip(t, i);
return i;
}
State(char * input_str)
{
// Ano, vím, že je to ošklivé, ale prostě parsovat JSON v C/C++ je za trest
int r;
jsmn_parser p;
int t_len = 100000000;
jsmntok_t * t = new jsmntok_t[t_len]; /* We expect no more than this count of tokens (jsmn limitation)*/
jsmn_init(&p);
r = jsmn_parse(&p, input_str, strlen(input_str), t, t_len);
assert(!(r < 0));
assert(!(r < 1 || t[0].type != JSMN_OBJECT));
int teams_count, team_id;
int state_tok, world_tok;
for (int i = 1, c=0; c < t[0].size;i = js_skip(t, i), c++)
{
//printf("- %.*s %d\n", t[i].end - t[i].start, input_str + t[i].start, t[i].size);
if (jsoneq(input_str, &t[i], "teams_count") == 0)
teams_count = atoi(input_str + t[i+1].start);
if (jsoneq(input_str, &t[i], "team_id") == 0)
team_id = atoi(input_str + t[i+1].start);
if (jsoneq(input_str, &t[i], "time_to_response") == 0)
time_to_response = atoi(input_str + t[i+1].start);
if (jsoneq(input_str, &t[i], "round_number") == 0)
round_number = atoi(input_str + t[i+1].start);
if (jsoneq(input_str, &t[i], "state") == 0)
state_tok = i+1;
;
}
assert(state_tok);
for(int i=0; i<teams_count; i++)
teams.push_back(new Team(i, i==team_id));
my_team = teams[team_id];
for (int i = state_tok+1, c=0; c < t[state_tok].size;i = js_skip(t, i), c++)
{
if (jsoneq(input_str, &t[i], "world") == 0)
world_tok = i+1;
;
}
assert(world_tok);
for (int i = world_tok+1, x=0; x < t[world_tok].size;i = js_skip(t, i), x++)
{
vector<Field *> current_row;
for (int j = i+1, y=0; y < t[i].size;j = js_skip(t, j), y++)
{
Field *current_field = new Field(x,y);
int members_tok;
for (int k = j+1, c=0; c < t[j].size;k = js_skip(t, k), c++)
{
if (jsoneq(input_str, &t[k], "hill") == 0)
current_field->hill = input_str[t[k+1].start] == 't';
if (jsoneq(input_str, &t[k], "home_for_team") == 0)
if(input_str[t[k+1].start] != 'n')
{
current_field->home_for_team = teams[atoi(input_str+t[k+1].start)];
current_field->home_for_team->home = current_field;
}
if (jsoneq(input_str, &t[k], "occupied_by_team") == 0)
if(input_str[t[k+1].start] != 'n')
{
current_field->occupied_by_team = teams[atoi(input_str+t[k+1].start)];
current_field->occupied_by_team->occupied.push_back(current_field);
}
if (jsoneq(input_str, &t[k], "protected_for_team") == 0)
if(input_str[t[k+1].start] != 'n')
{
current_field->protected_for_team = teams[atoi(input_str+t[k+1].start)];
current_field->protected_for_team->protected_fields.push_back(current_field);
}
if (jsoneq(input_str, &t[k], "members") == 0)
members_tok = k+1;
}
for (int k = members_tok+1, c=0; c < t[members_tok].size;k = js_skip(t, k), c++)
{
auto m = new Member(current_field);
for (int l = k+1, d=0; d < t[k].size;l = js_skip(t, l), d++)
{
// printf("%d %d: %.*s %d\n", x,y, t[l].end - t[l].start, input_str + t[l].start, t[l].size);
if (jsoneq(input_str, &t[l], "id") == 0)
m->id = atoi(input_str + t[l+1].start);
if (jsoneq(input_str, &t[l], "team") == 0)
m->team = teams[atoi(input_str+t[l+1].start)];
}
m->team->members.push_back(m);
current_field->members.push_back(m);
}
current_row.push_back(current_field);
}
world.push_back(current_row);
}
}
void print_turn()
{
for(Team *t: teams)
if(!t->is_me)
for(Member *m: t->members)
if(m->action != STAY)
{
fprintf(stderr, "Voják cizího týmu má přiřazenou akci.");
exit(1);
}
bool first = true;
printf("{\"members\": [");
for(Member *m: my_team->members)
{
if(!first) printf(", ");
const char * action = "stay";
if(m->action == UP) action = "up";
if(m->action == LEFT) action = "left";
if(m->action == DOWN) action = "down";
if(m->action == RIGHT) action = "right";
printf("{\"id\": %d, \"action\": \"%s\"}", m->id, action);
first = false;
}
printf("]}");
}
};
State* state;
// Algoritmy
// otoč směr podle jiného otočení
Direction combine_directions(Direction a, Direction b)
{
if (a == STAY || b == STAY)
{
fprintf(stderr, "Nelze kombinovat se STAY.");
exit(1);
}
return (Direction) ((a + b) % 4);
}
// získej opačný směr
Direction invert_direction(Direction a)
{
if (a == STAY) return STAY;
return combine_directions(a, DOWN);
}
// další políčko v daném směru
Field* get_neighbour_field(Field* f, Direction direction)
{
int neighbour_i, neighbour_j;
switch (direction)
{
case UP:
neighbour_i = f->i - 1;
neighbour_j = f->j;
break;
case DOWN:
neighbour_i = f->i + 1;
neighbour_j = f->j;
break;
case LEFT:
neighbour_i = f->i;
neighbour_j = f->j - 1;
break;
case RIGHT:
neighbour_i = f->i;
neighbour_j = f->j + 1;
break;
default:
neighbour_i = f->i;
neighbour_j = f->j;
}
// zajisti, aby souřadnice byly v rozsahu herní plochy
neighbour_i %= state->world.size();
neighbour_j %= state->world[0].size();
return state->world[neighbour_i][neighbour_j];
}
// jestli daný tým může vstoupit na políčko
bool is_field_accessible(Field* f, Team* t)
{
if (f->hill) return false;
if (f->protected_for_team != NULL && f->protected_for_team != t) return false;
return true;
}
// Najdi nejkratší cestu od vojáka k cílovému políčku.
// Vrátí první krok, který má voják udělat.
// Pokud žádná cesta neexistuje, vrátí STAY.
Direction pathfind(Member* m, Field* goal)
{
// speciální případ: voják už je v cíli
if (m->field == goal) return STAY;
std::set<Field*> explored;
std::queue<Field*> queue;
queue.push(goal);
auto dirs = {UP, LEFT, DOWN, RIGHT};
while (!queue.empty())
{
auto field = queue.front();
queue.pop();
for (auto direction : dirs)
{
auto neighbour = get_neighbour_field(field, direction);
if (explored.find(neighbour) != explored.end()) continue;
if (!is_field_accessible(neighbour, m->team)) continue;
// pokud jsme našli vojáka, vrátíme první krok
if (neighbour == m->field) return invert_direction(direction);
queue.push(neighbour);
explored.insert(neighbour);
}
}
return STAY;
}
// Strategie
int main()
{
char * input_str;
scanf("%m[^\n]", &input_str);
state = new State(input_str);
// TODO: zde doplňte svou herní strategii
for(Member *m: state->my_team->members)
m->action = UP;
state->print_turn();
return 0;
}