हम एंड्रॉइड का उपयोग करके एंड्रॉइड के लिए एक गेम लिख रहे हैं। भाग २

सभी को नमस्कार!
जैसा कि वादा किया गया है, लेख का दूसरा भाग।
भ्रम से बचने के लिए, पढ़ने से पहले लेख का पहला भाग पढ़ें ।
पहले से ही समीक्षा की गई? फिर कैट में आपका स्वागत है जहां मैं खेल वस्तुओं के लिए पाठक का परिचय दूंगा।

और इसलिए पहले भाग को संक्षेप में, हमने सीखा कि कैसे बनावट को लोड और प्रदर्शित करना है, लेकिन एक पूर्ण गेम के लिए यह पर्याप्त नहीं है, और बनावट स्वयं हमारी वास्तव में मदद नहीं करेगी। बनावट के लिए उन सभी चीजों को करने के लिए, जिनकी हमें आवश्यकता हो सकती है, हम गेम ऑब्जेक्ट बनाएंगे, जो बदले में, इन बनावटों को समाहित करेंगे।

अब, पहले चीजें पहले।

चरण 1: इकाई

इकाई, एन्डजाइन वर्ग है, मैंने लंबे समय तक समझाया कि इसकी आवश्यकता क्यों है, मैं सिर्फ इतना कहूंगा कि यह व्यूग्रुप वर्ग का एक निश्चित एनालॉग है। हमें अपनी खेल वस्तुओं के लिए इसकी आवश्यकता होगी।

हमारे पास 2 प्रकार की वस्तुएं होंगी: स्थैतिक और गतिशील। गतिशील घूम सकता है, और स्थिर, क्रमशः, नहीं।

चरण 2: स्थैतिक वस्तु

चीजों को अधिक सुविधाजनक बनाने के लिए, गेमऑब्जेक्ट क्लास बनाएं।

public abstract class GameObject extends Entity {

protected Sprite mSprite;

public GameObject(final int posX, final int posY, final TextureRegion region) {
mSprite = new Sprite(posX * GameObjectsMap.CELL_SIZE, posY
* GameObjectsMap.CELL_SIZE, region);
attachChild(mSprite);
}

protected Sprite getSprite() {
return mSprite;
}

public static enum Type {
lasergun, mirror, target
}

abstract int onLaser( int angle);

abstract void attachTo(Scene scene);

}

* This source code was highlighted with Source Code Highlighter .

मैं आपका ध्यान onLaser विधि की ओर आकर्षित करना चाहता हूं, जो उस कोण का मूल्य लेती है जिस पर लेजर हमारे गेम ऑब्जेक्ट को हिट करता है। और यह एक नकारात्मक मूल्य लौटाएगा यदि वस्तु और प्रतिबिंब के कोण से कुछ भी विपरीत मामले में परिलक्षित नहीं होता है।

चरण 3: गतिशील वस्तु

उपरोक्त वर्ग स्थिर वस्तुओं के लिए उपयुक्त है। गतिशील के लिए, हमें इसे थोड़ा विस्तार देना होगा।

public abstract class DynamicGameObject extends GameObject {

public static final int DEG_0 = 0;
public static final int DEG_45 = 1;
public static final int DEG_90 = 2;
public static final int DEG_135 = 3;
public static final int DEG_180 = 4;
public static final int DEG_225 = 5;
public static final int DEG_270 = 6;
public static final int DEG_315 = 7;

private static final float ANGLE = 45f;

private int mAngle;

public DynamicGameObject(final int posX, final int posY, final int angle,
final TextureRegion region) {
super(posX, posY, region);
setAngle(angle);
}

public int getAngle() {
return mAngle;
}

public void setAngle( int angle) {
this .mAngle = angle;
rotateSprite();
}

public void rotateLeft() {
mAngle--;
if (mAngle < DEG_0) {
mAngle = DEG_315;
}
rotateSprite();
}

public void rotateRigth() {
mAngle++;
if (mAngle > DEG_315) {
mAngle = DEG_0;
}
rotateSprite();
}

public float getRotationAngle() {
return ANGLE * mAngle;
}

protected void rotateSprite() {
mSprite.setRotation(getRotationAngle());
}

}

* This source code was highlighted with Source Code Highlighter .

अब, हम महान उपलब्धियों के लिए तैयार हैं, हम अपनी वस्तु और उसके स्प्राइट को घुमा सकते हैं जैसे हम चाहते हैं। लेकिन कोड के प्रदर्शन की जांच करना अभी भी एक लंबा रास्ता है, और हमारे पास लेजर भी नहीं है। लेजर के लिए हमें क्या चाहिए? शुरू करने के लिए, उस आदिम को चुनें जिसे हम उपयोग करेंगे। जाहिर है, यह एक रेखा होगी, लेकिन यह देखते हुए कि हमारा लेजर वस्तुओं से परिलक्षित होगा, हमें कुछ और चाहिए।

चरण 4: जटिल गेम ऑब्जेक्ट

public class LaserLine extends Entity {

private static final float LINE_WIDTH = 3f;

LinkedList<Point> mPoints;
private final Point mStartPosition;
private int mAngle;

public LaserLine(Point startPosition, int angle) {
init();
mStartPosition = startPosition;
mPoints.add(mStartPosition);
mAngle = angle;
}

public void init() {
mPoints = new LinkedList<Point>();
}

public void clearPoints() {
mPoints.clear();
mPoints.add(mStartPosition);
}

public void addPoint(final int cellNumX, final int cellNumY) {
mPoints.add( new Point(cellNumX, cellNumY));
}

public void addPoint(Point point) {
mPoints.add( new Point(point));
}

public void buildLines() {
detachChildren();
Point previousPoint = null ;
for (Point point : mPoints) {
Ln.i(point.x + " " + point.y);
if (previousPoint != null ) {
attachChild(makeLine(previousPoint, point));
}
previousPoint = point;
}
Ln.i( "-------------" );
}

public final Line makeLine(final Point start, final Point end) {
final Line line = new Line(
(start.x + 0.5f) * GameObjectsMap.CELL_SIZE_X,
(start.y + 0.5f) * GameObjectsMap.CELL_SIZE_Y,
(end.x + 0.5f) * GameObjectsMap.CELL_SIZE_X,
(end.y + 0.5f) * GameObjectsMap.CELL_SIZE_Y);
line.setLineWidth(LINE_WIDTH);
line.setColor(1f, 0.1f, 0.1f, 0.75f);
return line;
}

public Point getStartPosition() {
return mStartPosition;
}

public void setAngle( int angle) {
mAngle = angle;
}

public int getAngle() {
return mAngle;
}
}

* This source code was highlighted with Source Code Highlighter .

यहां हमारे पास बहुत सारी दिलचस्प चीजें हैं। आगे देखते हुए, मैं कहूंगा कि हमारी सभी वस्तुएँ एक दो-आयामी सरणी में संग्रहीत की जाएंगी। यह तथ्य CELL_SIZE फ़ील्ड्स की मौजूदगी की व्याख्या करता है, साथ ही साथ मेकलाइन विधि में 0.5f को जोड़ने की आवश्यकता है, सेल के बहुत मध्य में होने की उम्मीद करता है। लेजर का निर्माण करने के लिए, हमें अंकों की एक सूची चाहिए। प्रत्येक लेजर सेगमेंट LaserLine के लिए "संलग्न" होगा। नतीजतन, दृश्य में हमारी वस्तु को जोड़ने पर, हम लेजर के सभी खंडों को देखेंगे।

अपने काम के परिणाम को देखने के लिए हमें एक और छोटी कक्षा लिखनी होगी।

public class LaserGun extends DynamicGameObject {

public LaserGun(final int posX, final int posY, final int angle,
final TextureRegion region) {
super(posX, posY, angle, region);
}

@Override
int onLaser( int angle) {
return -1;
}

@Override
void attachTo(Scene scene) {
scene.getChild(GameObjectsMap.GAME_OBJECTS_LAYER).attachChild(getSprite());
}

}

* This source code was highlighted with Source Code Highlighter .

लेजर हमारी बंदूक से परिलक्षित नहीं होते हैं, और स्प्राइट को गेम ऑब्जेक्ट्स की परत पर प्रदर्शित किया जाता है।

चरण 5: वस्तुओं को आकर्षित करें

अब हमारे StageActivity में कोड जोड़ें जो हमें यह सब देखने की अनुमति देगा।

public Scene onLoadScene() {
this .mEngine.registerUpdateHandler( new FPSLogger());

final Scene scene = new Scene(NUMBER_OF_LAYERS);
scene.setBackground( new SpriteBackground( new Sprite(0, 0, mTextures
.getBackground())));
LaserLine line = new LaserLine( new Point(3, 3), 0);
line.addPoint( new Point(4, 4));
line.addPoint( new Point(5, 2));
line.buildLines();
scene.getChild(GameObjectsMap.LASER_LAYER).attachChild(line);
LaserGun gun = new LaserGun(3, 3, 4, mTextures.getLaserGun());
gun.attachTo(scene);
return scene;
}

* This source code was highlighted with Source Code Highlighter .

मेरे हीरो पर, मैंने यह तस्वीर देखी:


हम यहां कोड ढूंढ रहे हैं ।

आज के लिए बस इतना ही। तीसरे भाग की अपेक्षा करें।

हमेशा की तरह, इच्छाएं, रचनात्मक प्रस्ताव और प्रश्न स्वीकार किए जाते हैं।

PS किसी कारण से मेरे लिए हीरो पर अज्ञात है, लेजर की मोटाई हमेशा 1px होती है, इसलिए डरें नहीं।
PPS कोड में, GameObjectsMap वर्ग का बार-बार उल्लेख किया गया है, हम भी डरते नहीं हैं, इसके बारे में अगले लेख में। और यहाँ वह है