CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Robots

From Rosetta Code
Robots is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
This page uses content from Wikipedia. The original article was at Robots_(computer_game). The list of authors can be seen in the page history. As with Rosetta Code, the text of Wikipedia is available under the GNU FDL. (See links for details on variance)


The task is to implement a clone of Ken Arnold's turn-based game Robots.

Simple game where its only objective is to escape from a number of robots, which have been programmed to kill the player.


C++[edit]

Windows Console implementation - No safe teleport is implemeted, just the random one.

RobotsCpp.png
 
#include <windows.h>
#include <iostream>
#include <ctime>
 
const int WID = 62, HEI = 42, INC = 10;
 
class coord : public COORD {
public:
coord( short x = 0, short y = 0 ) { set( x, y ); }
void set( short x, short y ) { X = x; Y = y; }
};
class winConsole {
public:
static winConsole* getInstamnce() {
if( 0 == inst ) {
inst = new winConsole();
}
return inst;
}
void showCursor( bool s ) {
CONSOLE_CURSOR_INFO ci = { 1, s };
SetConsoleCursorInfo( conOut, &ci );
}
void setColor( WORD clr ) { SetConsoleTextAttribute( conOut, clr ); }
void setCursor( coord p ) { SetConsoleCursorPosition( conOut, p ); }
void setSize( int w, int h ) {
coord crd( w + 1, h + 1 );
SetConsoleScreenBufferSize( conOut, crd );
SMALL_RECT rc = { 0, 0, WID, HEI };
SetConsoleWindowInfo( conOut, TRUE, &rc );
}
void flush() { FlushConsoleInputBuffer( conIn ); }
void kill() { delete inst; }
private:
winConsole() { conOut = GetStdHandle( STD_OUTPUT_HANDLE );
conIn = GetStdHandle( STD_INPUT_HANDLE ); showCursor( false ); }
static winConsole* inst;
HANDLE conOut, conIn;
};
class robots {
public:
robots() {
console = winConsole::getInstamnce();
console->setSize( WID, HEI );
}
~robots() { console->kill(); }
void play() {
char g; do {
console->showCursor( false );
robotsCount = 10; score = 0; alive = true;
clearBoard(); cursor.set( rand() % ( WID - 2 ) + 1, rand() % ( HEI - 2 ) + 1 );
brd[cursor.X + WID * cursor.Y] = '@'; createBoard();
do{
displayBoard(); getInput();
if( !aliveRobots ) {
robotsCount += INC; clearBoard();
brd[cursor.X + WID * cursor.Y] = '@'; createBoard();
}
} while( alive );
displayBoard(); console->setCursor( coord( 0, 24 ) ); console->setColor( 0x07 );
console->setCursor( coord( 10, 8 ) );
std::cout << "+----------------------------------------+";
console->setCursor( coord( 10, 9 ) );
std::cout << "| GAME OVER |";
console->setCursor( coord( 10, 10 ) );
std::cout << "| PLAY AGAIN(Y/N)? |";
console->setCursor( coord( 10, 11 ) );
std::cout << "+----------------------------------------+";
console->setCursor( coord( 39, 10 ) ); console->showCursor( true );
console->flush(); std::cin >> g;
} while( g == 'Y' || g == 'y' );
}
private:
void clearBoard() {
for( int y = 0; y < HEI; y++ ) {
for( int x = 0; x < WID; x++ ) {
brd[x + WID * y] = 32;
if( x == 0 || x == WID - 1 || y == 0 || y == HEI - 1 )
brd[x + WID * y] = '#';
}
}
}
void createBoard() {
aliveRobots = robotsCount;
int a, b; for( int x = 0; x < robotsCount; x++ ) {
do {
a = rand() % WID; b = rand() % HEI;
} while( brd[a + WID * b] != 32 );
brd[a + WID * b] = '+';
}
printScore();
}
void displayBoard() {
char t; console->setCursor( coord() );
for( int y = 0; y < HEI; y++ ) {
for( int x = 0; x < WID; x++ ) {
t = brd[x + WID * y];
switch( t ) {
case ' ': console->setColor( 0x00 ); break;
case '#': console->setColor( 0x09 ); break;
case '+': console->setColor( 0x0e ); break;
case 'Å': case '*': console->setColor( 0x0c ); break;
case '@': console->setColor( 0x0a );
}
std::cout << t;
}
std::cout << "\n";
}
}
void getInput() {
while( 1 ) {
if( ( GetAsyncKeyState( 'Q' ) & 0x8000 ) && cursor.X > 1 && cursor.Y > 1 )
{ execute( -1, -1 ); break; }
if( ( GetAsyncKeyState( 'W' ) & 0x8000 ) && cursor.Y > 1 )
{ execute( 0, -1 ); break; }
if( ( GetAsyncKeyState( 'E' ) & 0x8000 ) && cursor.X < WID - 2 && cursor.Y > 1 )
{ execute( 1, -1 ); break; }
if( ( GetAsyncKeyState( 'A' ) & 0x8000 ) && cursor.X > 1 )
{ execute( -1, 0 ); break; }
if( ( GetAsyncKeyState( 'D' ) & 0x8000 ) && cursor.X < WID - 2 )
{ execute( 1, 0 ); break; }
if( ( GetAsyncKeyState( 'Y' ) & 0x8000 ) && cursor.X > 1 && cursor.Y < HEI - 2 )
{ execute( -1, 1 ); break; }
if( ( GetAsyncKeyState( 'X' ) & 0x8000 ) && cursor.Y < HEI - 2 )
{ execute( 0, 1 ); break; }
if( ( GetAsyncKeyState( 'C' ) & 0x8000 ) && cursor.X < WID - 2 && cursor.Y < HEI - 2 )
{ execute( 1, 1 ); break; }
if( ( GetAsyncKeyState( 'T' ) & 0x8000 ) )
{ teleport(); moveRobots(); break; }
if( ( GetAsyncKeyState( 'Z' ) & 0x8000 ) )
{ waitForEnd(); break; }
}
console->flush(); printScore();
}
void teleport() {
brd[cursor.X + WID * cursor.Y] = 32;
cursor.X = rand() % ( WID - 2 ) + 1;
cursor.Y = rand() % ( HEI - 2 ) + 1;
int x = cursor.X + WID * cursor.Y;
if( brd[x] == '*' || brd[x] == '+' || brd[x] == '~' ) {
alive = false; brd[x] = 'Å';
} else brd[x] = '@';
}
void printScore() {
console->setCursor( coord( 0, HEI ) ); console->setColor( 0x2a );
std::cout << " SCORE: " << score << " ";
}
void execute( int x, int y ) {
brd[cursor.X + WID * cursor.Y] = 32; cursor.X += x; cursor.Y += y;
brd[cursor.X + WID * cursor.Y] = '@'; moveRobots();
}
void waitForEnd() {
while( aliveRobots && alive ) {
moveRobots(); displayBoard(); Sleep( 500 );
}
}
void moveRobots() {
int tx, ty;
for( int y = 0; y < HEI; y++ ) {
for( int x = 0; x < WID; x++ ) {
if( brd[x + WID * y] != '+' ) continue;
tx = x; ty = y;
if( tx < cursor.X ) tx++; else if( tx > cursor.X ) tx--;
if( ty < cursor.Y ) ty++; else if( ty > cursor.Y ) ty--;
if( tx != x || ty != y ) {
brd[x + WID * y] = 32;
if( brd[tx + WID * ty] == 32 ) brd[tx + WID * ty] = '~';
else checkCollision( tx, ty );
}
}
}
for( int x = 0; x < WID * HEI; x++ ) {
if( brd[x] == '~') brd[x] = '+';
}
}
void checkCollision( int x, int y ) {
if( cursor.X == x && cursor.Y == y ) {
alive = false; brd[x + y * WID] = 'Å'; return;
}
x = x + y * WID;
if( brd[x] == '*' || brd[x] == '+' || brd[x] == '~' ) {
if( brd[x] != '*' ) { aliveRobots--; score++; }
brd[x] = '*'; aliveRobots--; score++;
}
}
winConsole* console; char brd[WID * HEI];
int robotsCount, score, aliveRobots;
coord cursor; bool alive;
};
winConsole* winConsole::inst = 0;
int main( int argc, char* argv[] ) {
srand( ( unsigned )time( 0 ) );
SetConsoleTitle( "Robots" );
robots g; g.play(); return 0;
}
 

Java[edit]

Works with: Java version 8
import java.awt.*;
import static java.awt.BasicStroke.*;
import java.awt.event.*;
import static java.lang.Math.abs;
import static java.lang.String.format;
import java.util.Random;
import javax.swing.*;
 
public class Robots extends JPanel {
enum Grid {
Player("@"), Robot("+"), Scrap("*"), Mark("~");
 
Grid(String s) {
symbol = s;
}
final String symbol;
}
 
final static int[][] dirs = {{-1, 1}, {0, 1}, {1, 1}, {-1, 0}, {1, 0},
{-1, -1}, {0, -1}, {1, -1}};
 
final static Random rand = new Random();
 
final int nRows;
final int nCols;
 
Grid[][] grid;
int playerRow, playerCol, score, hiScore, level;
boolean gameOver = true;
Stroke dash;
 
public Robots() {
setPreferredSize(new Dimension(800, 650));
setBackground(Color.white);
setForeground(Color.lightGray);
setFont(new Font("SansSerif", Font.PLAIN, 18));
setFocusable(true);
 
nRows = 38;
nCols = 50;
 
dash = new BasicStroke(2.0f, CAP_BUTT, JOIN_MITER, 10.0f,
new float[]{5.0f}, 0.0f);
 
addMouseListener(new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
if (gameOver) {
startNewGame();
repaint();
}
}
});
 
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
 
if (keyCode == KeyEvent.VK_NUMPAD5) {
teleport();
 
} else {
int k = keyCode - KeyEvent.VK_NUMPAD1;
if (k >= 0 && k < 9) {
move(k > 4 ? --k : k);
}
}
repaint();
}
});
}
 
void startNewGame() {
level = 1;
if (score > hiScore)
hiScore = score;
score = 0;
initGrid();
gameOver = false;
}
 
void initGrid() {
grid = new Grid[nRows][nCols];
 
teleport();
 
int numRobots = 7 * level;
for (int i = 0; i < numRobots;) {
int r = rand.nextInt(nRows);
int c = rand.nextInt(nCols);
if (grid[r][c] == null) {
grid[r][c] = Grid.Robot;
i++;
}
}
}
 
boolean movePlayer(int r, int c) {
if (grid[r][c] != null) {
gameOver = true;
} else {
grid[playerRow][playerCol] = null;
playerRow = r;
playerCol = c;
grid[r][c] = Grid.Player;
}
return !gameOver;
}
 
void move(int d) {
int c = playerCol + dirs[d][0];
int r = playerRow + dirs[d][1];
 
if (!withinBounds(r, c))
return;
 
if (!movePlayer(r, c))
return;
 
for (int rr = 0; rr < nRows; rr++)
for (int cc = 0; cc < nCols; cc++) {
if (grid[rr][cc] == Grid.Robot) {
 
// calc new r and c based on dx + cc and dy + rr
int nc = (c == cc ? 0 : (c - cc) / abs(c - cc)) + cc;
int nr = (r == rr ? 0 : (r - rr) / abs(r - rr)) + rr;
 
if (!withinBounds(nr, nc))
continue;
 
grid[rr][cc] = null;
 
if (grid[nr][nc] == Grid.Player) {
gameOver = true;
return; /* EARLY RETURN */
 
} else if (grid[nr][nc] != null) {
score++;
if (grid[nr][nc] != Grid.Scrap)
score++;
grid[nr][nc] = Grid.Scrap;
 
} else {
// avoid processing the same robot twice
grid[nr][nc] = Grid.Mark;
}
}
}
 
int robotsLeft = 0;
for (int rr = 0; rr < nRows; rr++)
for (int cc = 0; cc < nCols; cc++) {
if (grid[rr][cc] == Grid.Mark)
grid[rr][cc] = Grid.Robot;
if (grid[rr][cc] == Grid.Robot)
robotsLeft++;
}
 
if (robotsLeft == 0) {
level++;
initGrid();
}
}
 
void teleport() {
movePlayer(rand.nextInt(nRows), rand.nextInt(nCols));
}
 
void drawBorder(Graphics2D g) {
g.setStroke(dash);
g.setColor(getForeground());
g.drawRect(22, 20, getWidth() - 41, getHeight() - 72);
}
 
void drawGrid(Graphics2D g) {
for (int r = 0; r < nRows; r++)
for (int c = 0; c < nCols; c++) {
if (grid[r][c] != null)
g.drawString(grid[r][c].symbol, 24 + c * 15, 36 + r * 15);
}
}
 
void drawStartScreen(Graphics2D g) {
g.setColor(Color.gray);
g.setFont(new Font("SansSerif", Font.BOLD, 48));
g.drawString("robots", 315, 280);
 
g.setFont(getFont());
g.drawString("(use numpad to move player)", 270, 350);
g.drawString("(teleport is numpad 5)", 300, 380);
g.drawString("(click to start)", 328, 410);
}
 
void drawScore(Graphics2D g) {
g.setColor(Color.gray);
g.setFont(getFont());
String s = format("hiscore  %s score  %s", hiScore, score);
g.drawString(s, 30, getHeight() - 17);
}
 
boolean withinBounds(int r, int c) {
return c >= 0 && c < nCols && r >= 0 && r < nRows;
}
 
@Override
public void paintComponent(Graphics gg) {
super.paintComponent(gg);
Graphics2D g = (Graphics2D) gg;
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
 
drawBorder(g);
drawScore(g);
if (gameOver) {
drawStartScreen(g);
} else {
drawGrid(g);
}
}
 
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setTitle("Robots");
f.setResizable(false);
f.add(new Robots(), BorderLayout.CENTER);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
});
}
}