Dokumentacja gry Skarb Labiryntu

19.01.2013 - Jakub Kowalski
Trudność

Przykładowe boty

Poniżej, w czterech językach programowania, zamieszczone zostały kody źródłowe dwóch przykładowych botów: architekta i poszukiwacza. Oba boty potrafią grać we wszystkich dostępnych trybach. Implementują one pewne proste strategie oraz pokazują zasady działania systemu i możliwe sposoby obsługi protokołu komunikacji. Boty te są dostępne w systemie pod następującymi nazwami: architekt labiryntu - SL_DocumentationArchitect.py, poszukiwacz skarbu - SL_DocumentationAdventurer.py.

Architekt

Strategia działania przedstawionego bota, zobrazowana poniższym rysunkiem, jest następująca:

architect_play
  1. Pobiera dane o rozmiarze labiryntu.
  2. Rozpoczyna budowę prostego labiryntu od z góry zadanego pola.
  3. Następnie w każdej turze albo kontynuuje budowę linii przeszkód albo stwierdza, że doszedł do krawędzi mapy i zawraca.
  4. Buduje tyle ścian na ile pozwala szerokość mapy, potem opuszcza wszystkie kolejne tury.
Python
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
size = int(raw_input("MazeSize\n"))
 
x, y = size-5, size-1
go = "UP"
 
while True:
   print "#PRINT go", go
   if y == 2 and go == "UP":
      x, y = x - 2, 1
      go = "DOWN"
   elif y == size - 3 and go == "DOWN":
      x, y = x - 2, size - 2
      go = "UP"
   elif go == "DOWN":
      y += 1
   elif go == "UP":
      y -= 1
 
   if x + y > 3 and (x, y) != (2, 2):
      print "PlaceObstacle", x, y
   else:
      go = "NOWHERE"
   print "#END"


C++
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <iostream>
 
using namespace std;
 
int main ()
{
   int size;
   cout << "MazeSize" << endl;
   cin >> size;
 
   int x=size-5, y=size-1;
   string go = "UP";
 
   while (true)
   {
      cout << "#PRINT go " << go << endl;
      if (y==2 && go=="UP")
      {
         x -= 2;
         y = 1;
         go = "DOWN";
      }
      else if (y==size-3 && go=="DOWN")
      {
         x -= 2;
         y = size-2;
         go = "UP";
      }
      else if (go=="DOWN")
      {
         y++;
      }
      else if (go=="UP")
      {
         y--;
      }
 
      if (x+y>3 && (x != 2 || y != 2))
         cout << "PlaceObstacle " << x << " " << y << endl;
      else
         go = "NOWHERE";
      cout << "#END" << endl;
   }
}


C#
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using System;
 
namespace TOMDocumentationBot
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("MazeSize");
            int size = int.Parse(Console.ReadLine());
 
            int x = size - 5, y = size - 1;
            var go = "UP";
 
            while (true)
            {
                Console.WriteLine("#PRINT go " + go);
                if (y == 2 && go == "UP")
                {
                    x -= 2;
                    y = 1;
                    go = "DOWN";
                }
                else if (y == size - 3 && go == "DOWN")
                {
                    x -= 2;
                    y = size - 2;
                    go = "UP";
                }
                else if (go == "DOWN")
                {
                    y++;
                }
                else if (go == "UP")
                {
                    y--;
                }
 
                if (x + y > 3 && (x != 2 || y != 2))
                    Console.WriteLine("PlaceObstacle {0} {1}", x, y);
                else
                    go = "NOWHERE";
                Console.WriteLine("#END");
            }
        }
    }
}


Java
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import java.util.Scanner;
 
public class program
{
   public static void main(String args[])
   {
        Scanner input = new Scanner(System.in);
        System.out.println("MazeSize");
        int size = input.nextInt();
 
        int x=size-5, y=size-1;
        String go = "UP";
 
        while (true)
        {
            System.out.println("#PRINT go " + go);
            if (y==2 && "UP".equals(go))
            {
               x -= 2;
               y = 1;
               go = "DOWN";
            }
            else if (y==size-3 && "DOWN".equals(go))
            {
               x -= 2;
               y = size-2;
               go = "UP";
            }
            else if ("DOWN".equals(go))
            {
               y++;
            }
            else if ("UP".equals(go))
            {
               y--;
            }
 
            if (x+y>3 && (x != 2 || y != 2))
                System.out.println("PlaceObstacle " + x + " " + y);
            else
               go = "NOWHERE";
            System.out.println("#END");
        }
   }
}

Poszukiwacz

Strategia działania przedstawionego bota jest następująca:

  1. Bot pobiera informacje o swoim najbliższym otoczeniu (polecenie FieldOfView jest dostępne w obu trybach rozgrywki).
  2. Stara się on iść prosto w pewnym wyznaczonym kierunku aż natrafi na przeszkodę.
  3. Jeżeli nie może już dalej iść prosto, to losuje jeden z kierunków gdzie może bezpiecznie zrobić krok.
  4. Bot nie zawraca (kierunek przeciwny do dotychczasowego nie podlega losowaniu), chyba że nie ma innego wyjścia.
  5. W międzyczasie program wypisuje (jako komunikaty testowe) zawartość swoich najważniejszych zmiennych.
Python
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import random
 
backward = -1
continuation = -1
moves = [False, False, False, False]
 
while True:
   view = []
   print "FieldOfView"
   for y in range(5):
      view.append(raw_input().split())
   print "#PRINT Pole widzenia to", view
   moves[0] = view[1][2] != 'O'
   moves[1] = view[2][3] != 'O'
   moves[2] = view[3][2] != 'O'
   moves[3] = view[2][1] != 'O'
   print "#PRINT Lista ruchow:", moves
   print "#PRINT Kierunek do kontynuacji:", continuation
   
   if continuation >= 0 and moves[continuation]:
      print "MakeStep", continuation
      print "#END"
      continue
   
   possibleMoves = [i for i in range(4) if moves[i]]
 
   if len(possibleMoves) > 1 and backward in possibleMoves:
      possibleMoves.remove(backward)
 
   print "#PRINT Losowy wybor z kierunkow", possibleMoves
   continuation = random.choice(possibleMoves)
   backward = (continuation + 2) % 4
   print "MakeStep", continuation
   print "#END"


C++
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <iostream>
#include <vector>
#include <algorithm>
#include <stdlib.h>
#include <time.h>
 
using namespace std;
 
int main ()
{
   srand ( time(NULL) );
   int backward = -1;
   int continuation = -1;
   string row;
   int moves[4] = {false};
 
   while (true)
   {
      vector<vector<char> > view(5, vector<char>(5));
      cout << "FieldOfView" << endl;
      for (int y = 0; y < 5; y++)
      {
         string row;
         getline(cin, row);
         for (int x = 0; x < 5; x++)
            view[y][x] = row[2*x];
      }
      cout << "#PRINT Pole widzenia to";
      for (int y = 0; y < 5; y++)
      {
         cout << " [";
         for (int x = 0; x < 5; x++)
            cout << " " << view[y][x];
         cout << " ]";
      }
      cout << endl;
 
      moves[0] = view[1][2] != 'O';
      moves[1] = view[2][3] != 'O';
      moves[2] = view[3][2] != 'O';
      moves[3] = view[2][1] != 'O';
 
      vector<int> possibleMoves;
      cout << "#PRINT Lista ruchow: [";
      for (int i = 0; i < 4; i++)
      {
            cout << " " << moves[i];
            if (moves[i]) possibleMoves.push_back(i);
      }
      cout << " ]" << endl;
      cout << "#PRINT Kierunek do kontynuacji: " << continuation << endl;
 
      if (possibleMoves.size() > 1)
         possibleMoves.erase(remove(possibleMoves.begin(), possibleMoves.end(), backward), possibleMoves.end());
      cout << "#PRINT Losowy wybor z kierunkow: [";
      for (int i = 0; i < possibleMoves.size(); i++)
            cout << " " << possibleMoves[i];
      cout << " ]" << endl;
 
      continuation = possibleMoves[rand()%possibleMoves.size()];
      backward = (continuation + 2) % 4;
      cout << "MakeStep " << continuation << endl << "#END" << endl;
   }
}


C#
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
using System;
using System.Collections.Generic;
 
namespace TOMDocumentationBot
{
    class Program
    {
        static void Main(string[] args)
        {
            var rand = new Random();
            var backward = -1;
            var continuation = -1;
            var moves = new[] {false, false, false, false};
 
            while (true)
            {
                var view = new List<string[]>();
                Console.WriteLine("FieldOfView");
                for (var y = 0; y < 5; y++)
                    view.Add(Console.ReadLine().Split());
                Console.Write("#PRINT Pole widzenia to");
                foreach (var row in view)
                {
                    Console.Write(" [");
                    foreach (var s in row)
                        Console.Write(" " + s);
                    Console.Write(" ]");
                }
                Console.WriteLine();
                moves[0] = view[1][2] != "O";
                moves[1] = view[2][3] != "O";
                moves[2] = view[3][2] != "O";
                moves[3] = view[2][1] != "O";
                Console.Write("#PRINT Lista ruchow: [");
                foreach (var b in moves)
                    Console.Write(" " + b);
                Console.WriteLine(" ]");
                Console.WriteLine("#PRINT Kierunek do kontynuacji: " + continuation);
 
                if (continuation >= 0 && moves[continuation])
                {
                    Console.WriteLine("MakeStep " + continuation);
                    Console.WriteLine("#END");
                    continue;
                }
 
                var possibleMoves = new List<int>();
                for (int i = 0; i < 4; i++) if (moves[i]) possibleMoves.Add(i);
 
                if (possibleMoves.Count > 0 && possibleMoves.Contains(backward))
                    possibleMoves.Remove(backward);
 
                Console.Write("#PRINT Losowy wybor z kierunkow [");
                foreach (var m in possibleMoves)
                    Console.Write(" " + m);
                Console.WriteLine(" ]");
                continuation = possibleMoves[rand.Next(possibleMoves.Count)];
                backward = (continuation + 2) % 4;
                Console.WriteLine("MakeStep " + continuation);
                Console.WriteLine("#END");
            }
        }
    }
}


Java
Pokaż/ukryj kod źródłowy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
 
public class program
{
   public static void main(String args[])
   {
        Scanner input = new Scanner(System.in);
        Random rand = new Random();
        int backward = -1;
        int continuation = -1;
        Boolean[] moves = {false, false, false, false};
 
        while (true)
        {
            ArrayList<ArrayList<String>> view = new ArrayList<ArrayList<String>>();
            System.out.println("FieldOfView");
            for (int y = 0; y < 5; y++)
                view.add(new ArrayList<String>(Arrays.asList(input.nextLine().split(" "))));
            System.out.println("#PRINT Pole widzenia to " + view);
            moves[0] = ! view.get(1).get(2).equals("O");
            moves[1] = ! view.get(2).get(3).equals("O");
            moves[2] = ! view.get(3).get(2).equals("O");
            moves[3] = ! view.get(2).get(1).equals("O");
            System.out.println("#PRINT Lista ruchow: " + Arrays.asList(moves));
            System.out.println("#PRINT Kierunek do kontynuacji: " + continuation);
 
            if (continuation >= 0 && moves[continuation])
            {
                System.out.println("MakeStep " + continuation);
                System.out.println("#END");
                continue;
            }
 
            ArrayList<Integer> possibleMoves = new ArrayList<Integer>();
            for (int i = 0; i <4; i++) if (moves[i]) possibleMoves.add(i);
 
            if (possibleMoves.size() > 0 && possibleMoves.contains(backward))
                possibleMoves.remove(new Integer(backward));
 
            System.out.println("#PRINT Losowy wybor z kierunkow " + possibleMoves);
            continuation = possibleMoves.get(rand.nextInt(possibleMoves.size()));
            backward = (continuation + 2) % 4;
 
            System.out.println("MakeStep " + continuation);
            System.out.println("#END");
        }
   }
}

0
Twoja ocena: Brak

Copyright © 2008-2010 Wrocławski Portal Informatyczny

design: rafalpolito.com