aBOTcalypse

Thiết kế một bot để cạnh tranh trong một thử thách King-of-the-Hill! Đây là một phát lại của một trò chơi bot mặc định.

Bảng là 2D, giống như một trò chơi video cuộn bên (nhưng không có bất kỳ cuộn nào).

Một bot hợp lệ phải chấp nhận một đại diện chuỗi đa dòng của khu vực của bảng mà nó có thể nhìn thấy và đưa ra một động thái cho bot.

Cơ học

Đây là một game sinh tồn. Ngày tận thế đã đến, và chỉ còn lại bot (và một nguồn cung cấp đá vô tận được lưu trữ trong không gian võng ). Mỗi bot được cung cấp một vị trí bắt đầu ngẫu nhiên, ở độ cao 0. Trong một lần di chuyển nhất định, bot có thể nghỉ ngơi, di chuyển, ném đá hoặc thả đá. Bots có thể chia sẻ không gian với những tảng đá đứng yên, nhưng một con bot va chạm với một con bot khác hoặc một thiên thạch bị giết, cũng như một con bot bị đá ném trúng.

• Trọng lực: bot và đá phải nằm trên sàn của bảng hoặc trên đá khác; nghỉ ngơi trên một cái gì đó khác (không khí, sao băng, bot, v.v.) để lại một "không được hỗ trợ". Bot hoặc đá không được hỗ trợ sẽ rơi cho đến khi chúng được hỗ trợ; một cú rơi lớn hơn một khoảng trống sẽ giết chết một con bot và một con bot bên dưới một tảng đá hoặc bot rơi xuống cũng bị giết. Điều này có nghĩa là cố gắng di chuyển hoặc thả xuống sẽ chỉ hoạt động nếu bot hiện đang chia sẻ không gian với một tảng đá (nếu không bot / rock sẽ rơi xuống 1 khoảng trống). Một không gian có thể trở nên "không được hỗ trợ" nếu tảng đá bên dưới nó rơi xuống hoặc bị phá hủy bởi thiên thạch hoặc đạn .
• Thiên thạch: Mỗi lượt một thiên thạch rơi vào bảng từ trên xuống. Một thiên thạch có vận tốc 2 độ, với một góc ngẫu nhiên được chọn đồng đều trong phạm vi [-180,0] và vị trí x bắt đầu ngẫu nhiên. Thiên thạch rơi theo một đường thẳng dọc theo quỹ đạo đã cho cho đến khi chúng va phải thứ gì đó, tại thời điểm chúng biến mất. Lưu ý rằng làm tròn trong chuyển động của thiên thạch là 0 (theo trăn int()).
• Projectiles: Một bot có thể chọn ném một hòn đá bất kỳ khoảng cách nào lên đến độ cao của nó. Một hòn đá ném di chuyển theo một đường thẳng cho đến khi nó chạm vào một thứ gì đó (tất cả trong một lượt, không giống như một thiên thạch; những hòn đá ném không xuất hiện trên bảng), ở độ dốc - elevation / max distance. Lưu ý rằng đá ném bắt đầu quỹ đạo của chúng tại x + - 1 hình vuông. Ví dụ: nếu bot ở độ cao 5 và ném trái khoảng cách 1, đá sẽ bắt đầu (x-1,5)và kết thúc tại (x-2,0). Va chạm chỉ được kiểm tra theo các bước dx=1và dyđược làm tròn về 0 (theo trăn int()).

Đầu vào

Mỗi bot có thể nhìn thấy một hình vuông 20 pixel theo mỗi hướng (khoảng cách Ch Quashev = 20), cho đến ranh giới của bảng. Có 8 ký tự khác nhau trong mỗi chuỗi đầu vào:

• '#' (ranh giới bảng)
• '.' (không khí)
• '@'(sao băng)
• '&' (đá)
• 'e'/ 's'(bot kẻ thù, hoặc chính nó)
• 'E'/ 'S'(bot kẻ thù, hoặc chính nó, chia sẻ không gian với một tảng đá)

Đây là một ví dụ đầu vào (ngắt dòng sẽ là \n):

..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............................#
..............@...............#
.....................E........#
.....................&........#
.....................&........#
.....................&........#
.....................&........#
...........@.........&........#
....................s&........#
###############################

Đầu ra

Có bốn hành động mà một bot có thể thực hiện mỗi lượt.

• rest (nghĩa đen là ngồi và không làm gì cả)
• move <direction>di chuyển một không gian bot trong bất kỳ của bốn hướng, up, down, left, hoặc right. Chuyển động làm cho bot rơi xuống nếu không gian mới không được hỗ trợ bởi sàn hoặc đá ( fall > 1 = bot.kill()).
• drop <direction>đặt ("giọt") một hòn đá theo hướng được chỉ định. Thả một tảng đá lên (tức là đặt một tảng đá vào hình vuông [bot_x, bot_y+1]) hoặc sang một bên khiến nó rơi xuống cho đến khi được hỗ trợ (có thể rơi vào bot trong khi drop up). drop downđặt một hòn đá ở vị trí tương tự như bot, nếu chưa có đá ở đó.
• throw <direction> <distance>ném một hòn đá theo cơ học "đạn" ở trên, với khoảng cách tối đa được chỉ định. Khoảng cách tối đa không liên quan để ném lên hoặc xuống - vật phóng va chạm với hình vuông bên dưới (cho down) hoặc cố gắng va chạm với hình vuông bên trên (cho up) và sau đó với hình vuông của bot nếu nó không chạm vào bất cứ thứ gì (giết bot) .

Một bot trong cuộc thi phải xuất ra một chuỗi vô hướng với hành động của nó khi nhận được chuỗi đầu vào.

Giao diện

Một bot phải bao gồm một chương trình duy nhất có thể được gọi thông qua python 2 subprocess. Bất kỳ lệnh nào sẽ được chỉ định và sẽ được lưu trong tệp được gọi command.txt; trước khi trò chơi bắt đầu, bộ điều khiển sẽ thực hiện từng lệnh theo command.txtthứ tự và sau đó lệnh cuối cùng sẽ được sử dụng để chuyển đầu vào cho bot từ đó trở đi.

Một bot có thể có một tệp lưu trữ duy nhất được gọi storage.txttrong thư mục của nó; bot "Thrower mặc định" hiển thị một triển khai ví dụ, sử dụng json để lưu trạng thái của nó trong các lượt khác nhau. Ngoài ra, vui lòng bao gồm đầu ra gỡ lỗi ở chế độ chỉ ghi errlog.txt, tôi sẽ chuyển qua trong trường hợp bot của bạn bị lỗi trong khi chạy. Tôi sẽ đảm bảo chạy một số thử nghiệm với mỗi bot, để thử và tìm bất kỳ lỗi nào trước đó.

Chấm điểm

Tổng số điểm của bot bằng với số lượt mà nó sống sót, được tích lũy qua các trò chơi X có độ dài tối đa Y. Hiện tại , X,Y = 10, 500; nếu các bot kéo dài trong một thời gian dài, tôi sẽ tăng Y và nếu chúng tồn tại trong một thời gian ngắn, tôi sẽ tăng X.

Mã điều khiển được tìm thấy trong bộ điều khiển ; rất cám ơn @Nathan Merrill vì DDOS koth của anh ấy mà tôi đã điều chỉnh mã Communicator.

Python 2, Edoltot

Edoltot muốn trốn trong một góc và xây dựng một tòa tháp. Họ sẽ chạy đến một đầu, dựng lên một chút, rồi bắt đầu thả đá để xây tường. Edoltot không thích du khách, và sẽ ném đá vào bất cứ ai đến quá gần tháp của họ. Nếu tất cả trở nên sai lầm khủng khiếp và sự cố xoáy, nó sẽ tự rơi xuống một tảng đá

import sys
from random import randint
class edgebot():    

    def playtime(self,board):
        try:   
            self.max_height = 5    
            board = board.splitlines()

            #find edgebot
            for y in xrange(0,len(board)):
                row = board[y]
                symbol = 's' if row.count('s') else 'S'
                x = row.find(symbol)
                if x >= 0:
                    self.height = 20 - y
                    break

            ground = board[len(board)-2]
            floor = board[len(board)-1]
            nasty_person = 'e' if ground.count('e') else 'E'
            bad_x = ground.find(nasty_person)
            side = ground.find('#')
            if abs(side - x) ==1:
                self.end_found = 1
            else:
                self.end_found = 0

            if side - x == -1:
                self.direction = 'right'
            else:
                self.direction = 'left'       


            #Bad edgebot! No climbing out of the game!           
            if floor[x] != '#':
                if board[self.height-1][x] == '&':
                    dist = randint(3,self.height)
                    return 'throw ' + self.direction + ' ' + `dist`
                elif symbol =='S':
                    return 'drop up'
                else:
                    return 'move down'

            #Edgebot will go through you to find a corner. You have been warned.    
            elif abs(x - bad_x) <=2:
                if x - bad_x >0:
                    return 'throw left 1'
                else:
                    return 'throw right 1'

            #edgebot wants to hide in a corner
            elif self.end_found ==0:
                if side == -1:
                    return 'move right'#edgebot is right-handed
                elif side - x < -1:
                    return 'move left'
                elif side - x > 1:
                    return 'move right'

            #Too close! Throw rocks at it!
            elif self.height+1>= abs(x-bad_x) and abs(x-bad_x) >=3:
                distance = abs(x - bad_x) - 2
                if distance < 1:
                    return 'throw ' + self.direction + ' 1'
                else:
                    return 'throw ' + self.direction + ' ' +`distance - 1`
                self.max_height += 2 #people came close, edgebot needs to be higher up!

            #edgebot wants a home in the corner        
            elif self.height <self.max_height :
                if symbol =='S':
                    return 'move up'
                else:
                    return 'drop down'

            #edgebot wants a wall. edgebot has, at best, a limited understanding of architecture        
            elif bad_x < 3 or self.height+1<abs(x-bad_x):
                if self.direction == 'right' and row[x+1] == '&':
                    self.max_height += 2
                    return 'drop down'
                elif self.direction == 'left' and row[x-1] == '&':
                    self.max_height += 2
                    return 'move down'
                else:
                    return 'drop ' + self.direction         

            else:
                return 'drop down' #Not sure? Hide under a rock!
        except:
            return 'drop up' #All gone horribly wrong? Squish.


print edgebot().playtime(sys.argv[1])  

Xin lỗi cho tất cả các chỉnh sửa, đã không chạy đủ các trường hợp thử nghiệm trước khi gửi. Có một vấn đề nhỏ là anh chàng nhỏ bé sẽ cố gắng trèo lên đầu bảng trong thời gian đủ, nhưng hy vọng đó sẽ không phải là vấn đề trong hầu hết các trận đấu. Bây giờ, Edrideot chỉ nên ném đá khoảng cách ngẫu nhiên khi nó leo lên đủ cao

Chỉnh sửa lần cuối cho bây giờ. Bây giờ Edoltot sẽ ném đá vào bất cứ ai đủ gần giữa nó và bức tường. Không có nghĩa là nó tự thoát ra bằng cách chạy qua một ai đó