স্পেস ইনভাইডারদের একটি ইডিওম্যাটিক স্কাল / এলডাব্লুজেজিএল বাস্তবায়ন হ্যাশকেল / ওপেনজিএল বাস্তবায়নের মতো দেখতে খুব বেশি লাগে না। একটি হাস্কেল বাস্তবায়ন লেখার পক্ষে আমার মতে আরও ভাল অনুশীলন হতে পারে। তবে আপনি যদি স্কালার সাথে লেগে থাকতে চান তবে কীভাবে এটি কার্যকরী শৈলীতে লিখতে হয় তার জন্য এখানে কিছু ধারণা।
কেবল অপরিবর্তনীয় বস্তু ব্যবহার করার চেষ্টা করুন। আপনার কাছে এমন একটি Gameবস্তু থাকতে পারে যা একটি Player, ক Set[Invader](ব্যবহারের বিষয়ে নিশ্চিত হন immutable.Set) ইত্যাদি রাখে Playeran একটি দিন update(state: Game): Player(এটিও নিতে পারে depressedKeys: Set[Int]ইত্যাদি), এবং অন্যান্য ক্লাসগুলিকে একই পদ্ধতি দেয়।
যদৃচ্ছতা জন্য scala.util.RandomHaskell, মত অপরিবর্তনীয় নয় System.Random, কিন্তু আপনি আপনার নিজের immmutable জেনারেটরের করতে পারে। এটি এক অদক্ষ তবে এটি ধারণাটি প্রদর্শন করে।
case class ImmutablePRNG(val seed: Long) extends Immutable {
lazy val nextLong: (Long, ImmutableRNG) =
(seed, ImmutablePRNG(new Random(seed).nextLong()))
...
}
কীবোর্ড / মাউস ইনপুট এবং রেন্ডারিংয়ের জন্য, অশুচি ফাংশনগুলি কল করার কোনও উপায় নেই। তারা হাস্কেলতেও অপরিষ্কার, তারা এগুলিকে কেবল আবদ্ধ করে IOরেখেছে যাতে আপনার প্রকৃত ফাংশনগুলি প্রযুক্তিগতভাবে খাঁটি হয় (তারা নিজেরাই রাষ্ট্র পড়েন বা লেখেন না, তারা যে রুটিনগুলি বর্ণনা করেন এবং রানটাইম সিস্টেম সেই রুটিনগুলি কার্যকর করে) ।
শুধু আপনার অপরিবর্তনীয় বস্তু, I / O কোড রাখি না Game, Playerএবং Invader। আপনি Playerএকটি renderপদ্ধতি দিতে পারেন , তবে এটির মতো দেখতে হবে
render(state: Game, buffer: Image): Image
দুর্ভাগ্যক্রমে এটি LWJGL এর সাথে যথাযথভাবে খাপ খায় না কারণ এটি এতটা রাষ্ট্র-ভিত্তিক, তবে আপনি এটির উপরে নিজের বিমূর্ততা তৈরি করতে পারেন। আপনার কাছে এমন একটি ImmutableCanvasক্লাস থাকতে পারে যা একটি এডব্লিউটি রাখে Canvasএবং এর blit(এবং অন্যান্য পদ্ধতি) অন্তর্নিহিত ক্লোন করতে পারে Canvas, এটি পাস করতে পারে Display.setParent, তারপরে রেন্ডারিং সম্পাদন করে এবং Canvasনতুনটি (আপনার অপরিবর্তনীয় মোড়কে) ফিরিয়ে দিতে পারে ।
আপডেট : এখানে কিছু জাভা কোড দেখানো হচ্ছে যাতে আমি এটি সম্পর্কে কীভাবে যাব। (আমি স্কালায় প্রায় একই কোডটি লিখতাম, কেবলমাত্র একটি অপরিবর্তনীয় সেট অন্তর্নির্মিত এবং প্রতিটি লুপের জন্য কয়েকটি লুপগুলি মানচিত্র বা ভাঁজ দ্বারা প্রতিস্থাপন করা যেতে পারে except) আমি এমন একটি প্লেয়ার তৈরি করেছি যা ঘুরে বেড়ায় এবং গুলি চালায়, তবে আমি কোডটি ইতিমধ্যে দীর্ঘায়িত হওয়ায় শত্রুগুলি যুক্ত করেনি। আমি অনুলিপি-অনুলিপি সম্পর্কে প্রায় সমস্ত কিছুই তৈরি করেছি - আমি মনে করি এটি সবচেয়ে গুরুত্বপূর্ণ ধারণা।
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import static java.awt.event.KeyEvent.*;
// An immutable wrapper around a Set. Doesn't implement Set or Collection
// because that would require quite a bit of code.
class ImmutableSet<T> implements Iterable<T> {
final Set<T> backingSet;
// Construct an empty set.
ImmutableSet() {
backingSet = new HashSet<T>();
}
// Copy constructor.
ImmutableSet(ImmutableSet<T> src) {
backingSet = new HashSet<T>(src.backingSet);
}
// Return a new set with an element added.
ImmutableSet<T> plus(T elem) {
ImmutableSet<T> copy = new ImmutableSet<T>(this);
copy.backingSet.add(elem);
return copy;
}
// Return a new set with an element removed.
ImmutableSet<T> minus(T elem) {
ImmutableSet<T> copy = new ImmutableSet<T>(this);
copy.backingSet.remove(elem);
return copy;
}
boolean contains(T elem) {
return backingSet.contains(elem);
}
@Override public Iterator<T> iterator() {
return backingSet.iterator();
}
}
// An immutable, copy-on-write wrapper around BufferedImage.
class ImmutableImage {
final BufferedImage backingImage;
// Construct a blank image.
ImmutableImage(int w, int h) {
backingImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
}
// Copy constructor.
ImmutableImage(ImmutableImage src) {
backingImage = new BufferedImage(
src.backingImage.getColorModel(),
src.backingImage.copyData(null),
false, null);
}
// Clear the image.
ImmutableImage clear(Color c) {
ImmutableImage copy = new ImmutableImage(this);
Graphics g = copy.backingImage.getGraphics();
g.setColor(c);
g.fillRect(0, 0, backingImage.getWidth(), backingImage.getHeight());
return copy;
}
// Draw a filled circle.
ImmutableImage fillCircle(int x, int y, int r, Color c) {
ImmutableImage copy = new ImmutableImage(this);
Graphics g = copy.backingImage.getGraphics();
g.setColor(c);
g.fillOval(x - r, y - r, r * 2, r * 2);
return copy;
}
}
// An immutable, copy-on-write object describing the player.
class Player {
final int x, y;
final int ticksUntilFire;
Player(int x, int y, int ticksUntilFire) {
this.x = x;
this.y = y;
this.ticksUntilFire = ticksUntilFire;
}
// Construct a player at the starting position, ready to fire.
Player() {
this(SpaceInvaders.W / 2, SpaceInvaders.H - 50, 0);
}
// Update the game state (repeatedly called for each game tick).
GameState update(GameState currentState) {
// Update the player's position based on which keys are down.
int newX = x;
if (currentState.keyboard.isDown(VK_LEFT) || currentState.keyboard.isDown(VK_A))
newX -= 2;
if (currentState.keyboard.isDown(VK_RIGHT) || currentState.keyboard.isDown(VK_D))
newX += 2;
// Update the time until the player can fire.
int newTicksUntilFire = ticksUntilFire;
if (newTicksUntilFire > 0)
--newTicksUntilFire;
// Replace the old player with an updated player.
Player newPlayer = new Player(newX, y, newTicksUntilFire);
return currentState.setPlayer(newPlayer);
}
// Update the game state in response to a key press.
GameState keyPressed(GameState currentState, int key) {
if (key == VK_SPACE && ticksUntilFire == 0) {
// Fire a bullet.
Bullet b = new Bullet(x, y);
ImmutableSet<Bullet> newBullets = currentState.bullets.plus(b);
currentState = currentState.setBullets(newBullets);
// Make the player wait 25 ticks before firing again.
currentState = currentState.setPlayer(new Player(x, y, 25));
}
return currentState;
}
ImmutableImage render(ImmutableImage img) {
return img.fillCircle(x, y, 20, Color.RED);
}
}
// An immutable, copy-on-write object describing a bullet.
class Bullet {
final int x, y;
static final int radius = 5;
Bullet(int x, int y) {
this.x = x;
this.y = y;
}
// Update the game state (repeatedly called for each game tick).
GameState update(GameState currentState) {
ImmutableSet<Bullet> bullets = currentState.bullets;
bullets = bullets.minus(this);
if (y + radius >= 0)
// Add a copy of the bullet which has moved up the screen slightly.
bullets = bullets.plus(new Bullet(x, y - 5));
return currentState.setBullets(bullets);
}
ImmutableImage render(ImmutableImage img) {
return img.fillCircle(x, y, radius, Color.BLACK);
}
}
// An immutable, copy-on-write snapshot of the keyboard state at some time.
class KeyboardState {
final ImmutableSet<Integer> depressedKeys;
KeyboardState(ImmutableSet<Integer> depressedKeys) {
this.depressedKeys = depressedKeys;
}
KeyboardState() {
this(new ImmutableSet<Integer>());
}
GameState keyPressed(GameState currentState, int key) {
return currentState.setKeyboard(new KeyboardState(depressedKeys.plus(key)));
}
GameState keyReleased(GameState currentState, int key) {
return currentState.setKeyboard(new KeyboardState(depressedKeys.minus(key)));
}
boolean isDown(int key) {
return depressedKeys.contains(key);
}
}
// An immutable, copy-on-write description of the entire game state.
class GameState {
final Player player;
final ImmutableSet<Bullet> bullets;
final KeyboardState keyboard;
GameState(Player player, ImmutableSet<Bullet> bullets, KeyboardState keyboard) {
this.player = player;
this.bullets = bullets;
this.keyboard = keyboard;
}
GameState() {
this(new Player(), new ImmutableSet<Bullet>(), new KeyboardState());
}
GameState setPlayer(Player newPlayer) {
return new GameState(newPlayer, bullets, keyboard);
}
GameState setBullets(ImmutableSet<Bullet> newBullets) {
return new GameState(player, newBullets, keyboard);
}
GameState setKeyboard(KeyboardState newKeyboard) {
return new GameState(player, bullets, newKeyboard);
}
// Update the game state (repeatedly called for each game tick).
GameState update() {
GameState current = this;
current = current.player.update(current);
for (Bullet b : current.bullets)
current = b.update(current);
return current;
}
// Update the game state in response to a key press.
GameState keyPressed(int key) {
GameState current = this;
current = keyboard.keyPressed(current, key);
current = player.keyPressed(current, key);
return current;
}
// Update the game state in response to a key release.
GameState keyReleased(int key) {
GameState current = this;
current = keyboard.keyReleased(current, key);
return current;
}
ImmutableImage render() {
ImmutableImage img = new ImmutableImage(SpaceInvaders.W, SpaceInvaders.H);
img = img.clear(Color.BLUE);
img = player.render(img);
for (Bullet b : bullets)
img = b.render(img);
return img;
}
}
public class SpaceInvaders {
static final int W = 640, H = 480;
static GameState currentState = new GameState();
public static void main(String[] _) {
JFrame frame = new JFrame() {{
setSize(W, H);
setTitle("Space Invaders");
setContentPane(new JPanel() {
@Override public void paintComponent(Graphics g) {
BufferedImage img = SpaceInvaders.currentState.render().backingImage;
((Graphics2D) g).drawRenderedImage(img, new AffineTransform());
}
});
addKeyListener(new KeyAdapter() {
@Override public void keyPressed(KeyEvent e) {
currentState = currentState.keyPressed(e.getKeyCode());
}
@Override public void keyReleased(KeyEvent e) {
currentState = currentState.keyReleased(e.getKeyCode());
}
});
setLocationByPlatform(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}};
for (;;) {
currentState = currentState.update();
frame.repaint();
try {
Thread.sleep(20);
} catch (InterruptedException e) {}
}
}
}