# Prime Sieve in Java

A very concise prime sieve implementation in Java.

```/******************************************************************************
*  Compilation:  javac PrimeSieve.java
*  Execution:    java -Xmx1100m PrimeSieve n
*
*  Computes the number of primes less than or equal to n using
*  the Sieve of Eratosthenes.
*
*  % java PrimeSieve 25
*  The number of primes <= 25 is 9
*
*  % java PrimeSieve 100
*  The number of primes <= 100 is 25
*
*  % java -Xmx100m PrimeSieve 100000000
*  The number of primes <= 100000000 is 5761455
*
*  % java PrimeSieve -Xmx1100m 1000000000
*  The number of primes <= 1000000000 is 50847534
*
*
*  The 110MB and 1100MB is the amount of memory you want to allocate
*  to the program. If your computer has less, make this number smaller,
*  but it may prevent you from solving the problem for very large
*  values of n.
*
*
*                  n     Primes <= n
*  ---------------------------------
*                 10               4
*                100              25
*              1,000             168
*             10,000           1,229
*            100,000           9,592
*          1,000,000          78,498
*         10,000,000         664,579
*        100,000,000       5,761,455
*      1,000,000,000      50,847,534
*
******************************************************************************/

public class PrimeSieve {
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);

// initially assume all integers are prime
boolean[] isPrime = new boolean[n+1];
for (int i = 2; i <= n; i++) {
isPrime[i] = true;
}

// mark non-primes <= n using Sieve of Eratosthenes
for (int factor = 2; factor*factor <= n; factor++) {

// if factor is prime, then mark multiples of factor as nonprime
// suffices to consider mutiples factor, factor+1, ...,  n/factor
if (isPrime[factor]) {
for (int j = factor; factor*j <= n; j++) {
isPrime[factor*j] = false;
}
}
}

// count primes
int primes = 0;
for (int i = 2; i <= n; i++) {
if (isPrime[i]) primes++;
}
System.out.println("The number of primes <= " + n + " is " + primes);
}
}

```

A basic Java implementation of the classic game Space Invaders, designed by Tomohiro Nishikado and first released in 1978. It requires seven (!) class files in addition to the five images below.

shot.png

alien.png

bomb.png

explosion.png

player.png

```import java.awt.EventQueue;
import javax.swing.JFrame;

public class SpaceInvaders extends JFrame implements Commons {

initUI();
}

private void initUI() {

setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(BOARD_WIDTH, BOARD_HEIGHT);
setLocationRelativeTo(null);
setResizable(false);
}

public static void main(String[] args) {

EventQueue.invokeLater(() -> {
ex.setVisible(true);
});
}
}
```
```
public interface Commons {

public static final int BOARD_WIDTH = 358;
public static final int BOARD_HEIGHT = 350;
public static final int GROUND = 290;
public static final int BOMB_HEIGHT = 5;
public static final int ALIEN_HEIGHT = 12;
public static final int ALIEN_WIDTH = 12;
public static final int BORDER_RIGHT = 30;
public static final int BORDER_LEFT = 5;
public static final int GO_DOWN = 15;
public static final int NUMBER_OF_ALIENS_TO_DESTROY = 24;
public static final int CHANCE = 5;
public static final int DELAY = 17;
public static final int PLAYER_WIDTH = 15;
public static final int PLAYER_HEIGHT = 10;
}
```
```import javax.swing.ImageIcon;

public class Alien extends Sprite {

private Bomb bomb;
private final String alienImg = "src/images/alien.png";

public Alien(int x, int y) {

initAlien(x, y);
}

private void initAlien(int x, int y) {

this.x = x;
this.y = y;

bomb = new Bomb(x, y);
ImageIcon ii = new ImageIcon(alienImg);
setImage(ii.getImage());
}

public void act(int direction) {

this.x += direction;
}

public Bomb getBomb() {

return bomb;
}

public class Bomb extends Sprite {

private final String bombImg = "src/images/bomb.png";
private boolean destroyed;

public Bomb(int x, int y) {

initBomb(x, y);
}

private void initBomb(int x, int y) {

setDestroyed(true);
this.x = x;
this.y = y;
ImageIcon ii = new ImageIcon(bombImg);
setImage(ii.getImage());

}

public void setDestroyed(boolean destroyed) {

this.destroyed = destroyed;
}

public boolean isDestroyed() {

return destroyed;
}
}
}
```
```import java.awt.event.KeyEvent;

import javax.swing.ImageIcon;

public class Player extends Sprite implements Commons {

private final int START_Y = 280;
private final int START_X = 270;

private final String playerImg = "src/images/player.png";
private int width;

public Player() {

initPlayer();
}

private void initPlayer() {

ImageIcon ii = new ImageIcon(playerImg);

width = ii.getImage().getWidth(null);

setImage(ii.getImage());
setX(START_X);
setY(START_Y);
}

public void act() {

x += dx;

if (x <= 2) {
x = 2;
}

if (x >= BOARD_WIDTH - 2 * width) {
x = BOARD_WIDTH - 2 * width;
}
}

public void keyPressed(KeyEvent e) {

int key = e.getKeyCode();

if (key == KeyEvent.VK_LEFT) {

dx = -2;
}

if (key == KeyEvent.VK_RIGHT) {

dx = 2;
}
}

public void keyReleased(KeyEvent e) {

int key = e.getKeyCode();

if (key == KeyEvent.VK_LEFT) {

dx = 0;
}

if (key == KeyEvent.VK_RIGHT) {

dx = 0;
}
}
}
```
```import javax.swing.ImageIcon;

public class Shot extends Sprite {

private final String shotImg = "src/images/shot.png";
private final int H_SPACE = 6;
private final int V_SPACE = 1;

public Shot() {
}

public Shot(int x, int y) {

initShot(x, y);
}

private void initShot(int x, int y) {

ImageIcon ii = new ImageIcon(shotImg);
setImage(ii.getImage());

setX(x + H_SPACE);
setY(y - V_SPACE);
}
}
```
```
import java.awt.Image;

public class Sprite {

private boolean visible;
private Image image;
protected int x;
protected int y;
protected boolean dying;
protected int dx;

public Sprite() {

visible = true;
}

public void die() {

visible = false;
}

public boolean isVisible() {

return visible;
}

protected void setVisible(boolean visible) {

this.visible = visible;
}

public void setImage(Image image) {

this.image = image;
}

public Image getImage() {

return image;
}

public void setX(int x) {

this.x = x;
}

public void setY(int y) {

this.y = y;
}

public int getY() {

return y;
}

public int getX() {

return x;
}

public void setDying(boolean dying) {

this.dying = dying;
}

public boolean isDying() {

return this.dying;
}
}
```
```import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JPanel;

public class Board extends JPanel implements Runnable, Commons {

private Dimension d;
private ArrayList<Alien> aliens;
private Player player;
private Shot shot;

private final int ALIEN_INIT_X = 150;
private final int ALIEN_INIT_Y = 5;
private int direction = -1;
private int deaths = 0;

private boolean ingame = true;
private final String explImg = "src/images/explosion.png";
private String message = "Game Over";

public Board() {

initBoard();
}

private void initBoard() {

setFocusable(true);
d = new Dimension(BOARD_WIDTH, BOARD_HEIGHT);
setBackground(Color.black);

gameInit();
setDoubleBuffered(true);
}

@Override

gameInit();
}

public void gameInit() {

aliens = new ArrayList<>();

for (int i = 0; i < 4; i++) {
for (int j = 0; j < 6; j++) {

Alien alien = new Alien(ALIEN_INIT_X + 18 * j, ALIEN_INIT_Y + 18 * i);
}
}

player = new Player();
shot = new Shot();

if (animator == null || !ingame) {

animator.start();
}
}

public void drawAliens(Graphics g) {

Iterator it = aliens.iterator();

for (Alien alien: aliens) {

if (alien.isVisible()) {

g.drawImage(alien.getImage(), alien.getX(), alien.getY(), this);
}

if (alien.isDying()) {

alien.die();
}
}
}

public void drawPlayer(Graphics g) {

if (player.isVisible()) {

g.drawImage(player.getImage(), player.getX(), player.getY(), this);
}

if (player.isDying()) {

player.die();
ingame = false;
}
}

public void drawShot(Graphics g) {

if (shot.isVisible()) {

g.drawImage(shot.getImage(), shot.getX(), shot.getY(), this);
}
}

public void drawBombing(Graphics g) {

for (Alien a : aliens) {

Alien.Bomb b = a.getBomb();

if (!b.isDestroyed()) {

g.drawImage(b.getImage(), b.getX(), b.getY(), this);
}
}
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

g.setColor(Color.black);
g.fillRect(0, 0, d.width, d.height);
g.setColor(Color.green);

if (ingame) {

g.drawLine(0, GROUND, BOARD_WIDTH, GROUND);
drawAliens(g);
drawPlayer(g);
drawShot(g);
drawBombing(g);
}

Toolkit.getDefaultToolkit().sync();
g.dispose();
}

public void gameOver() {

Graphics g = this.getGraphics();

g.setColor(Color.black);
g.fillRect(0, 0, BOARD_WIDTH, BOARD_HEIGHT);

g.setColor(new Color(0, 32, 48));
g.fillRect(50, BOARD_WIDTH / 2 - 30, BOARD_WIDTH - 100, 50);
g.setColor(Color.white);
g.drawRect(50, BOARD_WIDTH / 2 - 30, BOARD_WIDTH - 100, 50);

Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = this.getFontMetrics(small);

g.setColor(Color.white);
g.setFont(small);
g.drawString(message, (BOARD_WIDTH - metr.stringWidth(message)) / 2,
BOARD_WIDTH / 2);
}

public void animationCycle() {

if (deaths == NUMBER_OF_ALIENS_TO_DESTROY) {

ingame = false;
message = "Game won!";
}

// player
player.act();

// shot
if (shot.isVisible()) {

int shotX = shot.getX();
int shotY = shot.getY();

for (Alien alien: aliens) {

int alienX = alien.getX();
int alienY = alien.getY();

if (alien.isVisible() && shot.isVisible()) {
if (shotX >= (alienX)
&& shotX <= (alienX + ALIEN_WIDTH)
&& shotY >= (alienY)
&& shotY <= (alienY + ALIEN_HEIGHT)) {
ImageIcon ii
= new ImageIcon(explImg);
alien.setImage(ii.getImage());
alien.setDying(true);
deaths++;
shot.die();
}
}
}

int y = shot.getY();
y -= 4;

if (y < 0) {
shot.die();
} else {
shot.setY(y);
}
}

// aliens

for (Alien alien: aliens) {

int x = alien.getX();

if (x >= BOARD_WIDTH - BORDER_RIGHT && direction != -1) {

direction = -1;
Iterator i1 = aliens.iterator();

while (i1.hasNext()) {

Alien a2 = (Alien) i1.next();
a2.setY(a2.getY() + GO_DOWN);
}
}

if (x <= BORDER_LEFT && direction != 1) {

direction = 1;

Iterator i2 = aliens.iterator();

while (i2.hasNext()) {

Alien a = (Alien) i2.next();
a.setY(a.getY() + GO_DOWN);
}
}
}

Iterator it = aliens.iterator();

while (it.hasNext()) {

Alien alien = (Alien) it.next();

if (alien.isVisible()) {

int y = alien.getY();

if (y > GROUND - ALIEN_HEIGHT) {
ingame = false;
message = "Invasion!";
}

alien.act(direction);
}
}

// bombs
Random generator = new Random();

for (Alien alien: aliens) {

int shot = generator.nextInt(15);
Alien.Bomb b = alien.getBomb();

if (shot == CHANCE && alien.isVisible() && b.isDestroyed()) {

b.setDestroyed(false);
b.setX(alien.getX());
b.setY(alien.getY());
}

int bombX = b.getX();
int bombY = b.getY();
int playerX = player.getX();
int playerY = player.getY();

if (player.isVisible() && !b.isDestroyed()) {

if (bombX >= (playerX)
&& bombX <= (playerX + PLAYER_WIDTH)
&& bombY >= (playerY)
&& bombY <= (playerY + PLAYER_HEIGHT)) {
ImageIcon ii
= new ImageIcon(explImg);
player.setImage(ii.getImage());
player.setDying(true);
b.setDestroyed(true);
}
}

if (!b.isDestroyed()) {

b.setY(b.getY() + 1);

if (b.getY() >= GROUND - BOMB_HEIGHT) {
b.setDestroyed(true);
}
}
}
}

@Override
public void run() {

long beforeTime, timeDiff, sleep;

beforeTime = System.currentTimeMillis();

while (ingame) {

repaint();
animationCycle();

timeDiff = System.currentTimeMillis() - beforeTime;
sleep = DELAY - timeDiff;

if (sleep < 0) {
sleep = 2;
}

try {
} catch (InterruptedException e) {
System.out.println("interrupted");
}

beforeTime = System.currentTimeMillis();
}

gameOver();
}

@Override
public void keyReleased(KeyEvent e) {

player.keyReleased(e);
}

@Override
public void keyPressed(KeyEvent e) {

player.keyPressed(e);

int x = player.getX();
int y = player.getY();

int key = e.getKeyCode();

if (key == KeyEvent.VK_SPACE) {

if (ingame) {
if (!shot.isVisible()) {
shot = new Shot(x, y);
}
}
}
}
}
}
```

# Java Pacman

A basic Java implementation of Pacman. Requires two class files, Board.java and Pacman.java in addition to the images files contained in this zip file.

```
import java.awt.EventQueue;
import javax.swing.JFrame;

public class Pacman extends JFrame {

public Pacman() {

initUI();
}

private void initUI() {

setTitle("Pacman");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setSize(380, 420);
setLocationRelativeTo(null);
setVisible(true);
}

public static void main(String[] args) {

EventQueue.invokeLater(() -> {
Pacman ex = new Pacman();
ex.setVisible(true);
});
}
}

```
```import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;

import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Board extends JPanel implements ActionListener {

private Dimension d;
private final Font smallFont = new Font("Helvetica", Font.BOLD, 14);

private Image ii;
private final Color dotColor = new Color(192, 192, 0);
private Color mazeColor;

private boolean inGame = false;
private boolean dying = false;

private final int BLOCK_SIZE = 24;
private final int N_BLOCKS = 15;
private final int SCREEN_SIZE = N_BLOCKS * BLOCK_SIZE;
private final int PAC_ANIM_DELAY = 2;
private final int PACMAN_ANIM_COUNT = 4;
private final int MAX_GHOSTS = 12;
private final int PACMAN_SPEED = 6;

private int pacAnimCount = PAC_ANIM_DELAY;
private int pacAnimDir = 1;
private int pacmanAnimPos = 0;
private int N_GHOSTS = 6;
private int pacsLeft, score;
private int[] dx, dy;
private int[] ghost_x, ghost_y, ghost_dx, ghost_dy, ghostSpeed;

private Image ghost;
private Image pacman1, pacman2up, pacman2left, pacman2right, pacman2down;
private Image pacman3up, pacman3down, pacman3left, pacman3right;
private Image pacman4up, pacman4down, pacman4left, pacman4right;

private int pacman_x, pacman_y, pacmand_x, pacmand_y;
private int req_dx, req_dy, view_dx, view_dy;

private final short levelData[] = {
19, 26, 26, 26, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 22,
21, 0, 0, 0, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20,
21, 0, 0, 0, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20,
21, 0, 0, 0, 17, 16, 16, 24, 16, 16, 16, 16, 16, 16, 20,
17, 18, 18, 18, 16, 16, 20, 0, 17, 16, 16, 16, 16, 16, 20,
17, 16, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 16, 24, 20,
25, 16, 16, 16, 24, 24, 28, 0, 25, 24, 24, 16, 20, 0, 21,
1, 17, 16, 20, 0, 0, 0, 0, 0, 0, 0, 17, 20, 0, 21,
1, 17, 16, 16, 18, 18, 22, 0, 19, 18, 18, 16, 20, 0, 21,
1, 17, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 20, 0, 21,
1, 17, 16, 16, 16, 16, 20, 0, 17, 16, 16, 16, 20, 0, 21,
1, 17, 16, 16, 16, 16, 16, 18, 16, 16, 16, 16, 20, 0, 21,
1, 17, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 20, 0, 21,
1, 25, 24, 24, 24, 24, 24, 24, 24, 24, 16, 16, 16, 18, 20,
9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 25, 24, 24, 24, 28
};

private final int validSpeeds[] = {1, 2, 3, 4, 6, 8};
private final int maxSpeed = 6;

private int currentSpeed = 3;
private short[] screenData;
private Timer timer;

public Board() {

initVariables();
initBoard();
}

private void initBoard() {

setFocusable(true);

setBackground(Color.black);
setDoubleBuffered(true);
}

private void initVariables() {

screenData = new short[N_BLOCKS * N_BLOCKS];
mazeColor = new Color(5, 100, 5);
d = new Dimension(400, 400);
ghost_x = new int[MAX_GHOSTS];
ghost_dx = new int[MAX_GHOSTS];
ghost_y = new int[MAX_GHOSTS];
ghost_dy = new int[MAX_GHOSTS];
ghostSpeed = new int[MAX_GHOSTS];
dx = new int[4];
dy = new int[4];

timer = new Timer(40, this);
timer.start();
}

@Override

initGame();
}

private void doAnim() {

pacAnimCount--;

if (pacAnimCount <= 0) {
pacAnimCount = PAC_ANIM_DELAY;
pacmanAnimPos = pacmanAnimPos + pacAnimDir;

if (pacmanAnimPos == (PACMAN_ANIM_COUNT - 1) || pacmanAnimPos == 0) {
pacAnimDir = -pacAnimDir;
}
}
}

private void playGame(Graphics2D g2d) {

if (dying) {

death();

} else {

movePacman();
drawPacman(g2d);
moveGhosts(g2d);
checkMaze();
}
}

private void showIntroScreen(Graphics2D g2d) {

g2d.setColor(new Color(0, 32, 48));
g2d.fillRect(50, SCREEN_SIZE / 2 - 30, SCREEN_SIZE - 100, 50);
g2d.setColor(Color.white);
g2d.drawRect(50, SCREEN_SIZE / 2 - 30, SCREEN_SIZE - 100, 50);

String s = "Press s to start.";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = this.getFontMetrics(small);

g2d.setColor(Color.white);
g2d.setFont(small);
g2d.drawString(s, (SCREEN_SIZE - metr.stringWidth(s)) / 2, SCREEN_SIZE / 2);
}

private void drawScore(Graphics2D g) {

int i;
String s;

g.setFont(smallFont);
g.setColor(new Color(96, 128, 255));
s = "Score: " + score;
g.drawString(s, SCREEN_SIZE / 2 + 96, SCREEN_SIZE + 16);

for (i = 0; i < pacsLeft; i++) {
g.drawImage(pacman3left, i * 28 + 8, SCREEN_SIZE + 1, this);
}
}

private void checkMaze() {

short i = 0;
boolean finished = true;

while (i < N_BLOCKS * N_BLOCKS && finished) {

if ((screenData[i] & 48) != 0) {
finished = false;
}

i++;
}

if (finished) {

score += 50;

if (N_GHOSTS < MAX_GHOSTS) {
N_GHOSTS++;
}

if (currentSpeed < maxSpeed) {
currentSpeed++;
}

initLevel();
}
}

private void death() {

pacsLeft--;

if (pacsLeft == 0) {
inGame = false;
}

continueLevel();
}

private void moveGhosts(Graphics2D g2d) {

short i;
int pos;
int count;

for (i = 0; i < N_GHOSTS; i++) {
if (ghost_x[i] % BLOCK_SIZE == 0 && ghost_y[i] % BLOCK_SIZE == 0) {
pos = ghost_x[i] / BLOCK_SIZE + N_BLOCKS * (int) (ghost_y[i] / BLOCK_SIZE);

count = 0;

if ((screenData[pos] & 1) == 0 && ghost_dx[i] != 1) {
dx[count] = -1;
dy[count] = 0;
count++;
}

if ((screenData[pos] & 2) == 0 && ghost_dy[i] != 1) {
dx[count] = 0;
dy[count] = -1;
count++;
}

if ((screenData[pos] & 4) == 0 && ghost_dx[i] != -1) {
dx[count] = 1;
dy[count] = 0;
count++;
}

if ((screenData[pos] & 8) == 0 && ghost_dy[i] != -1) {
dx[count] = 0;
dy[count] = 1;
count++;
}

if (count == 0) {

if ((screenData[pos] & 15) == 15) {
ghost_dx[i] = 0;
ghost_dy[i] = 0;
} else {
ghost_dx[i] = -ghost_dx[i];
ghost_dy[i] = -ghost_dy[i];
}

} else {

count = (int) (Math.random() * count);

if (count > 3) {
count = 3;
}

ghost_dx[i] = dx[count];
ghost_dy[i] = dy[count];
}

}

ghost_x[i] = ghost_x[i] + (ghost_dx[i] * ghostSpeed[i]);
ghost_y[i] = ghost_y[i] + (ghost_dy[i] * ghostSpeed[i]);
drawGhost(g2d, ghost_x[i] + 1, ghost_y[i] + 1);

if (pacman_x > (ghost_x[i] - 12) && pacman_x < (ghost_x[i] + 12)
&& pacman_y > (ghost_y[i] - 12) && pacman_y < (ghost_y[i] + 12)
&& inGame) {

dying = true;
}
}
}

private void drawGhost(Graphics2D g2d, int x, int y) {

g2d.drawImage(ghost, x, y, this);
}

private void movePacman() {

int pos;
short ch;

if (req_dx == -pacmand_x && req_dy == -pacmand_y) {
pacmand_x = req_dx;
pacmand_y = req_dy;
view_dx = pacmand_x;
view_dy = pacmand_y;
}

if (pacman_x % BLOCK_SIZE == 0 && pacman_y % BLOCK_SIZE == 0) {
pos = pacman_x / BLOCK_SIZE + N_BLOCKS * (int) (pacman_y / BLOCK_SIZE);
ch = screenData[pos];

if ((ch & 16) != 0) {
screenData[pos] = (short) (ch & 15);
score++;
}

if (req_dx != 0 || req_dy != 0) {
if (!((req_dx == -1 && req_dy == 0 && (ch & 1) != 0)
|| (req_dx == 1 && req_dy == 0 && (ch & 4) != 0)
|| (req_dx == 0 && req_dy == -1 && (ch & 2) != 0)
|| (req_dx == 0 && req_dy == 1 && (ch & 8) != 0))) {
pacmand_x = req_dx;
pacmand_y = req_dy;
view_dx = pacmand_x;
view_dy = pacmand_y;
}
}

// Check for standstill
if ((pacmand_x == -1 && pacmand_y == 0 && (ch & 1) != 0)
|| (pacmand_x == 1 && pacmand_y == 0 && (ch & 4) != 0)
|| (pacmand_x == 0 && pacmand_y == -1 && (ch & 2) != 0)
|| (pacmand_x == 0 && pacmand_y == 1 && (ch & 8) != 0)) {
pacmand_x = 0;
pacmand_y = 0;
}
}
pacman_x = pacman_x + PACMAN_SPEED * pacmand_x;
pacman_y = pacman_y + PACMAN_SPEED * pacmand_y;
}

private void drawPacman(Graphics2D g2d) {

if (view_dx == -1) {
drawPacnanLeft(g2d);
} else if (view_dx == 1) {
drawPacmanRight(g2d);
} else if (view_dy == -1) {
drawPacmanUp(g2d);
} else {
drawPacmanDown(g2d);
}
}

private void drawPacmanUp(Graphics2D g2d) {

switch (pacmanAnimPos) {
case 1:
g2d.drawImage(pacman2up, pacman_x + 1, pacman_y + 1, this);
break;
case 2:
g2d.drawImage(pacman3up, pacman_x + 1, pacman_y + 1, this);
break;
case 3:
g2d.drawImage(pacman4up, pacman_x + 1, pacman_y + 1, this);
break;
default:
g2d.drawImage(pacman1, pacman_x + 1, pacman_y + 1, this);
break;
}
}

private void drawPacmanDown(Graphics2D g2d) {

switch (pacmanAnimPos) {
case 1:
g2d.drawImage(pacman2down, pacman_x + 1, pacman_y + 1, this);
break;
case 2:
g2d.drawImage(pacman3down, pacman_x + 1, pacman_y + 1, this);
break;
case 3:
g2d.drawImage(pacman4down, pacman_x + 1, pacman_y + 1, this);
break;
default:
g2d.drawImage(pacman1, pacman_x + 1, pacman_y + 1, this);
break;
}
}

private void drawPacnanLeft(Graphics2D g2d) {

switch (pacmanAnimPos) {
case 1:
g2d.drawImage(pacman2left, pacman_x + 1, pacman_y + 1, this);
break;
case 2:
g2d.drawImage(pacman3left, pacman_x + 1, pacman_y + 1, this);
break;
case 3:
g2d.drawImage(pacman4left, pacman_x + 1, pacman_y + 1, this);
break;
default:
g2d.drawImage(pacman1, pacman_x + 1, pacman_y + 1, this);
break;
}
}

private void drawPacmanRight(Graphics2D g2d) {

switch (pacmanAnimPos) {
case 1:
g2d.drawImage(pacman2right, pacman_x + 1, pacman_y + 1, this);
break;
case 2:
g2d.drawImage(pacman3right, pacman_x + 1, pacman_y + 1, this);
break;
case 3:
g2d.drawImage(pacman4right, pacman_x + 1, pacman_y + 1, this);
break;
default:
g2d.drawImage(pacman1, pacman_x + 1, pacman_y + 1, this);
break;
}
}

private void drawMaze(Graphics2D g2d) {

short i = 0;
int x, y;

for (y = 0; y < SCREEN_SIZE; y += BLOCK_SIZE) {
for (x = 0; x < SCREEN_SIZE; x += BLOCK_SIZE) {

g2d.setColor(mazeColor);
g2d.setStroke(new BasicStroke(2));

if ((screenData[i] & 1) != 0) {
g2d.drawLine(x, y, x, y + BLOCK_SIZE - 1);
}

if ((screenData[i] & 2) != 0) {
g2d.drawLine(x, y, x + BLOCK_SIZE - 1, y);
}

if ((screenData[i] & 4) != 0) {
g2d.drawLine(x + BLOCK_SIZE - 1, y, x + BLOCK_SIZE - 1,
y + BLOCK_SIZE - 1);
}

if ((screenData[i] & 8) != 0) {
g2d.drawLine(x, y + BLOCK_SIZE - 1, x + BLOCK_SIZE - 1,
y + BLOCK_SIZE - 1);
}

if ((screenData[i] & 16) != 0) {
g2d.setColor(dotColor);
g2d.fillRect(x + 11, y + 11, 2, 2);
}

i++;
}
}
}

private void initGame() {

pacsLeft = 3;
score = 0;
initLevel();
N_GHOSTS = 6;
currentSpeed = 3;
}

private void initLevel() {

int i;
for (i = 0; i < N_BLOCKS * N_BLOCKS; i++) {
screenData[i] = levelData[i];
}

continueLevel();
}

private void continueLevel() {

short i;
int dx = 1;
int random;

for (i = 0; i < N_GHOSTS; i++) {

ghost_y[i] = 4 * BLOCK_SIZE;
ghost_x[i] = 4 * BLOCK_SIZE;
ghost_dy[i] = 0;
ghost_dx[i] = dx;
dx = -dx;
random = (int) (Math.random() * (currentSpeed + 1));

if (random > currentSpeed) {
random = currentSpeed;
}

ghostSpeed[i] = validSpeeds[random];
}

pacman_x = 7 * BLOCK_SIZE;
pacman_y = 11 * BLOCK_SIZE;
pacmand_x = 0;
pacmand_y = 0;
req_dx = 0;
req_dy = 0;
view_dx = -1;
view_dy = 0;
dying = false;
}

ghost = new ImageIcon("images/ghost.png").getImage();
pacman1 = new ImageIcon("images/pacman.png").getImage();
pacman2up = new ImageIcon("images/up1.png").getImage();
pacman3up = new ImageIcon("images/up2.png").getImage();
pacman4up = new ImageIcon("images/up3.png").getImage();
pacman2down = new ImageIcon("images/down1.png").getImage();
pacman3down = new ImageIcon("images/down2.png").getImage();
pacman4down = new ImageIcon("images/down3.png").getImage();
pacman2left = new ImageIcon("images/left1.png").getImage();
pacman3left = new ImageIcon("images/left2.png").getImage();
pacman4left = new ImageIcon("images/left3.png").getImage();
pacman2right = new ImageIcon("images/right1.png").getImage();
pacman3right = new ImageIcon("images/right2.png").getImage();
pacman4right = new ImageIcon("images/right3.png").getImage();

}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

doDrawing(g);
}

private void doDrawing(Graphics g) {

Graphics2D g2d = (Graphics2D) g;

g2d.setColor(Color.black);
g2d.fillRect(0, 0, d.width, d.height);

drawMaze(g2d);
drawScore(g2d);
doAnim();

if (inGame) {
playGame(g2d);
} else {
showIntroScreen(g2d);
}

g2d.drawImage(ii, 5, 5, this);
Toolkit.getDefaultToolkit().sync();
g2d.dispose();
}

@Override
public void keyPressed(KeyEvent e) {

int key = e.getKeyCode();

if (inGame) {
if (key == KeyEvent.VK_LEFT) {
req_dx = -1;
req_dy = 0;
} else if (key == KeyEvent.VK_RIGHT) {
req_dx = 1;
req_dy = 0;
} else if (key == KeyEvent.VK_UP) {
req_dx = 0;
req_dy = -1;
} else if (key == KeyEvent.VK_DOWN) {
req_dx = 0;
req_dy = 1;
} else if (key == KeyEvent.VK_ESCAPE && timer.isRunning()) {
inGame = false;
} else if (key == KeyEvent.VK_PAUSE) {
if (timer.isRunning()) {
timer.stop();
} else {
timer.start();
}
}
} else {
if (key == 's' || key == 'S') {
inGame = true;
initGame();
}
}
}

@Override
public void keyReleased(KeyEvent e) {

int key = e.getKeyCode();

if (key == Event.LEFT || key == Event.RIGHT
|| key == Event.UP || key == Event.DOWN) {
req_dx = 0;
req_dy = 0;
}
}
}

@Override
public void actionPerformed(ActionEvent e) {

repaint();
}
}
```

# Java Simple Graph

Graphing class using swing. Creates a JPanel with a plot of 4 points.
Original code can be found here.

```import java.awt.*;
import javax.swing.*;

public class PlotTest extends JPanel {
int[] data = { 25, 60, 42, 75 };

protected void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2 = (Graphics2D)g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
int w = getWidth();
int h = getHeight();
double xScale = (w - 2*PAD)/(data.length + 1);
double maxValue = 100.0;
double yScale = (h - 2*PAD)/maxValue;
// The origin location.
g2.setPaint(Color.red);
for(int j = 0; j &lt; data.length; j++) {
int x = x0 + (int)(xScale * (j+1));
int y = y0 - (int)(yScale * data[j]);
g2.fillOval(x-2, y-2, 4, 4);
}
}

public static void main(String[] args) {
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(400,400);
f.setLocation(200,200);
f.setVisible(true);
}
}
```

# Java Timer

A Java system timer that measures execution time of a loop in milliseconds.

```public class Timer{
public static void main(String[] args) {
final long startTime = System.currentTimeMillis();

for (int i = 0; i < 5; i++) {
//Do something
}

final long endTime = System.currentTimeMillis();
System.out.println("Total execution time: " + (endTime - startTime)  );
}
}

```

# Java Tetris

A simple Tetris game in Java by DataWraith.  Source code can be found here: https://gist.github.com/DataWraith/5236083.

```import java.awt.Color;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.util.ArrayList;
import java.util.Collections;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Tetris extends JPanel {

private static final long serialVersionUID = -8715353373678321308L;

private final Point[][][] Tetraminos = {
// I-Piece
{
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(3, 1) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(1, 3) },
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(3, 1) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(1, 3) }
},

// J-Piece
{
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(2, 0) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(2, 2) },
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(0, 2) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(0, 0) }
},

// L-Piece
{
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(2, 2) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(0, 2) },
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(0, 0) },
{ new Point(1, 0), new Point(1, 1), new Point(1, 2), new Point(2, 0) }
},

// O-Piece
{
{ new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1) },
{ new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1) },
{ new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1) },
{ new Point(0, 0), new Point(0, 1), new Point(1, 0), new Point(1, 1) }
},

// S-Piece
{
{ new Point(1, 0), new Point(2, 0), new Point(0, 1), new Point(1, 1) },
{ new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2) },
{ new Point(1, 0), new Point(2, 0), new Point(0, 1), new Point(1, 1) },
{ new Point(0, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2) }
},

// T-Piece
{
{ new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(2, 1) },
{ new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(1, 2) },
{ new Point(0, 1), new Point(1, 1), new Point(2, 1), new Point(1, 2) },
{ new Point(1, 0), new Point(1, 1), new Point(2, 1), new Point(1, 2) }
},

// Z-Piece
{
{ new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(2, 1) },
{ new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(0, 2) },
{ new Point(0, 0), new Point(1, 0), new Point(1, 1), new Point(2, 1) },
{ new Point(1, 0), new Point(0, 1), new Point(1, 1), new Point(0, 2) }
}
};

private final Color[] tetraminoColors = {
Color.cyan, Color.blue, Color.orange, Color.yellow, Color.green, Color.pink, Color.red
};

private Point pieceOrigin;
private int currentPiece;
private int rotation;
private ArrayList<Integer> nextPieces = new ArrayList<Integer>();

private long score;
private Color[][] well;

// Creates a border around the well and initializes the dropping piece
private void init() {
well = new Color[12][24];
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 23; j++) {
if (i == 0 || i == 11 || j == 22) {
well[i][j] = Color.GRAY;
} else {
well[i][j] = Color.BLACK;
}
}
}
newPiece();
}

// Put a new, random piece into the dropping position
public void newPiece() {
pieceOrigin = new Point(5, 2);
rotation = 0;
if (nextPieces.isEmpty()) {
Collections.addAll(nextPieces, 0, 1, 2, 3, 4, 5, 6);
Collections.shuffle(nextPieces);
}
currentPiece = nextPieces.get(0);
nextPieces.remove(0);
}

// Collision test for the dropping piece
private boolean collidesAt(int x, int y, int rotation) {
for (Point p : Tetraminos[currentPiece][rotation]) {
if (well[p.x + x][p.y + y] != Color.BLACK) {
return true;
}
}
return false;
}

// Rotate the piece clockwise or counterclockwise
public void rotate(int i) {
int newRotation = (rotation + i) % 4;
if (newRotation < 0) {
newRotation = 3;
}
if (!collidesAt(pieceOrigin.x, pieceOrigin.y, newRotation)) {
rotation = newRotation;
}
repaint();
}

// Move the piece left or right
public void move(int i) {
if (!collidesAt(pieceOrigin.x + i, pieceOrigin.y, rotation)) {
pieceOrigin.x += i;
}
repaint();
}

// Drops the piece one line or fixes it to the well if it can't drop
public void dropDown() {
if (!collidesAt(pieceOrigin.x, pieceOrigin.y + 1, rotation)) {
pieceOrigin.y += 1;
} else {
fixToWell();
}
repaint();
}

// Make the dropping piece part of the well, so it is available for
// collision detection.
public void fixToWell() {
for (Point p : Tetraminos[currentPiece][rotation]) {
well[pieceOrigin.x + p.x][pieceOrigin.y + p.y] = tetraminoColors[currentPiece];
}
clearRows();
newPiece();
}

public void deleteRow(int row) {
for (int j = row-1; j > 0; j--) {
for (int i = 1; i < 11; i++) {
well[i][j+1] = well[i][j];
}
}
}

// Clear completed rows from the field and award score according to
// the number of simultaneously cleared rows.
public void clearRows() {
boolean gap;
int numClears = 0;

for (int j = 21; j > 0; j--) {
gap = false;
for (int i = 1; i < 11; i++) {
if (well[i][j] == Color.BLACK) {
gap = true;
break;
}
}
if (!gap) {
deleteRow(j);
j += 1;
numClears += 1;
}
}

switch (numClears) {
case 1:
score += 100;
break;
case 2:
score += 300;
break;
case 3:
score += 500;
break;
case 4:
score += 800;
break;
}
}

// Draw the falling piece
private void drawPiece(Graphics g) {
g.setColor(tetraminoColors[currentPiece]);
for (Point p : Tetraminos[currentPiece][rotation]) {
g.fillRect((p.x + pieceOrigin.x) * 26,
(p.y + pieceOrigin.y) * 26,
25, 25);
}
}

@Override
public void paintComponent(Graphics g)
{
// Paint the well
g.fillRect(0, 0, 26*12, 26*23);
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 23; j++) {
g.setColor(well[i][j]);
g.fillRect(26*i, 26*j, 25, 25);
}
}

// Display the score
g.setColor(Color.WHITE);
g.drawString("" + score, 19*12, 25);

// Draw the currently falling piece
drawPiece(g);
}

public static void main(String[] args) {
JFrame f = new JFrame("Tetris");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(12*26+10, 26*23+25);
f.setVisible(true);

final Tetris game = new Tetris();
game.init();

// Keyboard controls
public void keyTyped(KeyEvent e) {
}

public void keyPressed(KeyEvent e) {
switch (e.getKeyCode()) {
case KeyEvent.VK_UP:
game.rotate(-1);
break;
case KeyEvent.VK_DOWN:
game.rotate(+1);
break;
case KeyEvent.VK_LEFT:
game.move(-1);
break;
case KeyEvent.VK_RIGHT:
game.move(+1);
break;
case KeyEvent.VK_SPACE:
game.dropDown();
game.score += 1;
break;
}
}

public void keyReleased(KeyEvent e) {
}
});

// Make the falling piece drop every second
@Override public void run() {
while (true) {
try {
game.dropDown();
} catch ( InterruptedException e ) {}
}
}
}.start();
}
}
```

# Java Snake

A Java version of the classic game Snake. This game requires 2 class files: Board.java and Snake.java in addition to these three images:
Dot.png

Apple.png

To load the images, make a source folder called “images” in your eclipse project and add the image files.

```import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;

import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.Timer;

public class Board extends JPanel implements ActionListener {

private final int B_WIDTH = 300;
private final int B_HEIGHT = 300;
private final int DOT_SIZE = 10;
private final int ALL_DOTS = 900;
private final int RAND_POS = 29;
private final int DELAY = 140;

private final int x[] = new int[ALL_DOTS];
private final int y[] = new int[ALL_DOTS];

private int dots;
private int apple_x;
private int apple_y;

private boolean leftDirection = false;
private boolean rightDirection = true;
private boolean upDirection = false;
private boolean downDirection = false;
private boolean inGame = true;

private Timer timer;
private Image ball;
private Image apple;

public Board() {

setBackground(Color.black);
setFocusable(true);

setPreferredSize(new Dimension(B_WIDTH, B_HEIGHT));
initGame();
}

ImageIcon iid = new ImageIcon("images/dot.png");
ball = iid.getImage();

ImageIcon iia = new ImageIcon("images/apple.png");
apple = iia.getImage();

}

private void initGame() {

dots = 3;

for (int z = 0; z < dots; z++) {
x[z] = 50 - z * 10;
y[z] = 50;
}

locateApple();

timer = new Timer(DELAY, this);
timer.start();
}

@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);

doDrawing(g);
}

private void doDrawing(Graphics g) {

if (inGame) {

g.drawImage(apple, apple_x, apple_y, this);

for (int z = 0; z < dots; z++) {
if (z == 0) {
} else {
g.drawImage(ball, x[z], y[z], this);
}
}

Toolkit.getDefaultToolkit().sync();

} else {

gameOver(g);
}
}

private void gameOver(Graphics g) {

String msg = "Game Over";
Font small = new Font("Helvetica", Font.BOLD, 14);
FontMetrics metr = getFontMetrics(small);

g.setColor(Color.white);
g.setFont(small);
g.drawString(msg, (B_WIDTH - metr.stringWidth(msg)) / 2, B_HEIGHT / 2);
}

private void checkApple() {

if ((x[0] == apple_x) && (y[0] == apple_y)) {

dots++;
locateApple();
}
}

private void move() {

for (int z = dots; z > 0; z--) {
x[z] = x[(z - 1)];
y[z] = y[(z - 1)];
}

if (leftDirection) {
x[0] -= DOT_SIZE;
}

if (rightDirection) {
x[0] += DOT_SIZE;
}

if (upDirection) {
y[0] -= DOT_SIZE;
}

if (downDirection) {
y[0] += DOT_SIZE;
}
}

private void checkCollision() {

for (int z = dots; z > 0; z--) {

if ((z > 4) && (x[0] == x[z]) && (y[0] == y[z])) {
inGame = false;
}
}

if (y[0] >= B_HEIGHT) {
inGame = false;
}

if (y[0] < 0) {
inGame = false;
}

if (x[0] >= B_WIDTH) {
inGame = false;
}

if (x[0] < 0) {
inGame = false;
}

if(!inGame) {
timer.stop();
}
}

private void locateApple() {

int r = (int) (Math.random() * RAND_POS);
apple_x = ((r * DOT_SIZE));

r = (int) (Math.random() * RAND_POS);
apple_y = ((r * DOT_SIZE));
}

@Override
public void actionPerformed(ActionEvent e) {

if (inGame) {

checkApple();
checkCollision();
move();
}

repaint();
}

@Override
public void keyPressed(KeyEvent e) {

int key = e.getKeyCode();

if ((key == KeyEvent.VK_LEFT) && (!rightDirection)) {
leftDirection = true;
upDirection = false;
downDirection = false;
}

if ((key == KeyEvent.VK_RIGHT) && (!leftDirection)) {
rightDirection = true;
upDirection = false;
downDirection = false;
}

if ((key == KeyEvent.VK_UP) && (!downDirection)) {
upDirection = true;
rightDirection = false;
leftDirection = false;
}

if ((key == KeyEvent.VK_DOWN) && (!upDirection)) {
downDirection = true;
rightDirection = false;
leftDirection = false;
}
}
}
}
```
```import java.awt.EventQueue;
import javax.swing.JFrame;

public class Snake extends JFrame {

public Snake() {

setResizable(false);
pack();

setTitle("Snake");
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

public static void main(String[] args) {

EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
JFrame ex = new Snake();
ex.setVisible(true);
}
});
}
}
```