برمجة لعبة اطلاق نار ثنائية الأبعاد باستخدام Kotlin

        

import android.content.Context
import android.graphics.Canvas
import android.graphics.Paint
import android.view.SurfaceHolder
import android.view.SurfaceView

class GameView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {

    private val surfaceHolder: SurfaceHolder = holder
    private var gameLoopThread: GameLoopThread? = null
    private val backgroundColor = Paint().apply { color = android.graphics.Color.BLACK }

    init {
        surfaceHolder.addCallback(this)
        gameLoopThread = GameLoopThread(this)
        isFocusable = true
    }

    override fun surfaceCreated(holder: SurfaceHolder) {
        gameLoopThread?.isRunning = true
        gameLoopThread?.start()
    }

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
        // يمكنك إضافة منطق للتعامل مع تغيير حجم الشاشة هنا
    }

    override fun surfaceDestroyed(holder: SurfaceHolder) {
        var retry = true
        gameLoopThread?.isRunning = false
        while (retry) {
            try {
                gameLoopThread?.join()
                retry = false
            } catch (e: InterruptedException) {
                // حاول الانضمام مرة أخرى
            }
        }
    }

    override fun draw(canvas: Canvas) {
        super.draw(canvas)
        canvas.drawPaint(backgroundColor)
        // سيتم رسم عناصر اللعبة هنا
    }

    fun update() {
        // سيتم تحديث منطق اللعبة هنا
    }
}

class GameLoopThread(private val gameView: GameView) : Thread() {
    var isRunning: Boolean = false

    override fun run() {
        var lastTime = System.nanoTime()
        val targetFPS = 60
        val optimalTime = 1000000000.0 / targetFPS

        while (isRunning) {
            val now = System.nanoTime()
            val updateLength = now - lastTime
            lastTime = now
            val delta = updateLength / optimalTime

            gameView.update()
            val canvas: Canvas? = try {
                gameView.surfaceHolder.lockCanvas()
            } catch (e: Exception) {
                null
            }
            canvas?.let {
                synchronized(gameView.surfaceHolder) {
                    gameView.draw(it)
                }
                try {
                    gameView.surfaceHolder.unlockCanvasAndPost(it)
                } catch (e: Exception) {
                    e.printStackTrace()
                }
            }

            val sleepTime = (optimalTime - (System.nanoTime() - now)).toLong() / 1000000
            if (sleepTime > 0) {
                try {
                    sleep(sleepTime)
                } catch (e: InterruptedException) {
                    // لا تفعل شيئًا
                }
            }
        }
    }
}
        
      

import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint

data class Vector2(var x: Float = 0f, var y: Float = 0f)

open class GameObject(var position: Vector2, var speed: Float = 0f, var sprite: Bitmap? = null) {
    open fun draw(canvas: Canvas, paint: Paint) {
        sprite?.let {
            canvas.drawBitmap(it, position.x - it.width / 2, position.y - it.height / 2, paint)
        }
    }

    open fun update() {
        // منطق التحديث العام للكائنات
    }
}

class Player(position: Vector2, speed: Float, sprite: Bitmap?) : GameObject(position, speed, sprite) {
    override fun update() {
        // منطق حركة اللاعب
    }

    fun shoot(): Bullet {
        // إنشاء رصاصة جديدة من موقع اللاعب
        return Bullet(Vector2(position.x, position.y), 20f, null) // تحتاج إلى إضافة Sprite للرصاصة
    }
}

class Enemy(position: Vector2, speed: Float, sprite: Bitmap?) : GameObject(position, speed, sprite) {
    override fun update() {
        // منطق حركة العدو
    }
}

class Bullet(position: Vector2, speed: Float, sprite: Bitmap?) : GameObject(position, speed, sprite) {
    override fun update() {
        position.y -= speed // حركة الرصاصة للأعلى
    }
}


        
      

import android.content.Context
import android.graphics.BitmapFactory

fun loadBitmap(context: Context, resourceId: Int): Bitmap? {
    return BitmapFactory.decodeResource(context.resources, resourceId)
}

// في كلاس GameView أو مكان تهيئة اللعبة:
val playerSprite = loadBitmap(context, R.drawable.player_sprite)
val enemySprite = loadBitmap(context, R.drawable.enemy_sprite)
val bulletSprite = loadBitmap(context, R.drawable.bullet_sprite)

// عند إنشاء كائنات اللاعب والعدو والرصاص:
val player = Player(Vector2(width / 2f, height - 100f), 10f, playerSprite)
val enemies = mutableListOf<Enemy>()
val bullets = mutableListOf<Bullet>()




        
      

// في كلاس GameView:
private val player = Player(Vector2(width / 2f, height - 100f), 10f, playerSprite)
private val enemies = mutableListOf<Enemy>()
private val bullets = mutableListOf<Bullet>()
private var lastEnemySpawnTime = System.currentTimeMillis()
private val enemySpawnInterval = 1000L // ميلي ثانية

override fun update() {
    // تحديث حركة اللاعب (تحتاج إلى إضافة معالجة الإدخال)
    // player.position.x += player.speed * deltaTime

    // تحديث حركة الأعداء
    enemies.forEach { it.update() }

    // تحديث حركة الرصاصات
    bullets.forEach { it.update() }
    bullets.removeAll { it.position.y < 0 } // إزالة الرصاصات خارج الشاشة

    // إنشاء أعداء جدد بشكل دوري
    val currentTime = System.currentTimeMillis()
    if (currentTime - lastEnemySpawnTime > enemySpawnInterval) {
        val randomX = (0 until width).random().toFloat()
        enemies.add(Enemy(Vector2(randomX, 50f), 5f, enemySprite))
        lastEnemySpawnTime = currentTime
    }
}

override fun draw(canvas: Canvas) {
    super.draw(canvas)
    canvas.drawPaint(backgroundColor)
    player.draw(canvas, Paint())
    enemies.forEach { it.draw(canvas, Paint()) }
    bullets.forEach { it.draw(canvas, Paint()) }
}

fun shoot() {
    bullets.add(player.shoot())
}
        
      

// في كلاس GameView:
private var score = 0
private val scorePaint = Paint().apply {
    color = android.graphics.Color.WHITE
    textSize = 50f
}

override fun update() {
    // ... (تحديث حركة اللاعب والأعداء والرصاص) ...

    // اكتشاف التصادم بين الرصاصات والأعداء
    val enemiesToRemove = mutableListOf<Enemy>()
    val bulletsToRemove = mutableListOf<Bullet>()
    for (enemy in enemies) {
        for (bullet in bullets) {
            if (checkCollision(enemy, bullet)) {
                enemiesToRemove.add(enemy)
                bulletsToRemove.add(bullet)
                score += 10 // زيادة النقاط عند تدمير عدو
            }
        }
    }
    enemies.removeAll(enemiesToRemove)
    bullets.removeAll(bulletsToRemove)

    // اكتشاف التصادم بين اللاعب والأعداء (تحتاج إلى إضافة منطق إنهاء اللعبة/إنقاص الحياة)
    for (enemy in enemies) {
        if (checkCollision(player, enemy)) {
            // منطق إنهاء اللعبة أو إنقاص حياة اللاعب
            // gameEnded = true
        }
    }
}

override fun draw(canvas: Canvas) {
    super.draw(canvas)
    // ... (رسم اللاعب والأعداء والرصاص) ...
    canvas.drawText("Score: $score", 50f, 100f, scorePaint)
}

fun checkCollision(obj1: GameObject, obj2: GameObject): Boolean {
    obj1.sprite?.let { sprite1 ->
        obj2.sprite?.let { sprite2 ->
            val rect1 = android.graphics.RectF(
                obj1.position.x - sprite1.width / 2,
                obj1.position.y - sprite1.height / 2,
                obj1.position.x + sprite1.width / 2,
                obj1.position.y + sprite1.height / 2
            )
            val rect2 = android.graphics.RectF(
                obj2.position.x - sprite2.width / 2,
                obj2.position.y - sprite2.height / 2,
                obj2.position.x + sprite2.width / 2,
                obj2.position.y + sprite2.height / 2
            )
            return RectF.intersects(rect1, rect2)
        }
    }
    return false
}
        
      

import android.view.MotionEvent
import android.view.View

// في كلاس GameView:
init {
    // ... (تهيئة أخرى) ...
    setOnTouchListener(object : OnTouchListener {
        override fun onTouch(v: View?, event: MotionEvent?): Boolean {
            event?.let {
                when (it.action) {
                    MotionEvent.ACTION_DOWN -> {
                        // عند لمس الشاشة، قم بإطلاق النار
                        shoot()
                        return true
                    }
                    MotionEvent.ACTION_MOVE -> {
                        // تحديث موقع اللاعب بناءً على حركة اللمس
                        player.position.x = it.x
                        return true
                    }
                    MotionEvent.ACTION_UP -> {
                        // عند رفع الإصبع
                        return true
                    }
                }
            }
            return false
        }
    })
}
        
      

import android.content.Context

// في كلاس GameView أو مدير اللعبة:
private val PREFS_NAME = "MyGamePrefs"
private val KEY_HIGH_SCORE = "highScore"
private val sharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)

fun saveHighScore() {
    val editor = sharedPreferences.edit()
    editor.putInt(KEY_HIGH_SCORE, getHighScore())
    editor.apply()
}

fun getHighScore(): Int {
    return sharedPreferences.getInt(KEY_HIGH_SCORE, 0)
}

// عند انتهاء اللعبة أو في أي وقت تريد حفظ النتيجة:
if (score > getHighScore()) {
    saveHighScore()
}

// لعرض أعلى نتيجة:
// canvas.drawText("High Score: ${getHighScore()}", ...)