app/src/main/java/com/example/textadventure/ui/MapFragment.kt - master - username0273/TextAdventure

app/src/main/java/com/example/textadventure/ui/MapFragment.kt
227 строк9 KB
Simon
Исправлены баги при отображении интерфейса на планшетах
18 май 2026, 17:05
18 май 2026, 17:057728ad0
package com.example.textadventure.ui

import android.os.Bundle
import android.text.Spannable
import android.text.SpannableString
import android.text.style.AbsoluteSizeSpan
import android.text.style.ForegroundColorSpan
import androidx.fragment.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.FrameLayout
import android.widget.ImageView
import android.widget.TextView
import androidx.appcompat.app.AlertDialog
import androidx.core.content.ContextCompat
import androidx.core.view.doOnLayout
import com.example.textadventure.R
import com.example.textadventure.gamelogic.enums.LocationId
import com.example.textadventure.gamelogic.enums.NPC
import com.example.textadventure.gamelogic.enums.QuestState
import com.example.textadventure.gamelogic.enums.StoryFlag
import com.example.textadventure.gamelogic.enums.WeaponProperty
import com.example.textadventure.gamelogic.rolesystem.Player
import com.example.textadventure.gamelogic.quests.Quest

class MapFragment : Fragment() {
    private lateinit var gs: GameScreen
    private lateinit var player: Player
    private lateinit var markerContainer: FrameLayout
    private lateinit var mapImage: ImageView
    private lateinit var fogOfWarImage: ImageView
    private var playerMarker: ImageView? = null
    private var playerTokenId: Int = 0
    private val questMarkers = mutableMapOf<String, View>()

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        return inflater.inflate(R.layout.fragment_map, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        gs = requireActivity() as GameScreen
        player = gs.getPlayer()
        markerContainer = view.findViewById(R.id.markerContainer)
        mapImage = view.findViewById(R.id.mapImage)
        fogOfWarImage = view.findViewById(R.id.fogOfWar)

        playerTokenId = when (player.getWeaponProficiency()) {
            WeaponProperty.HEAVY -> R.drawable.mrk_token_street_fighter
            WeaponProperty.LIGHT -> R.drawable.mrk_token_fencer
            WeaponProperty.RANGED -> R.drawable.mrk_token_archer
        }

        updateMap()
    }

    // ---------------------------------------------------------------------------------------------
    // render map
    // ---------------------------------------------------------------------------------------------
    fun updateMap() {
        renderPlayerMarker()
        renderQuestMarkers()

        if (player.hasFlag(StoryFlag.MAP_UNLOCKED)) {
            fogOfWarImage.visibility = View.GONE
        } else {
            fogOfWarImage.visibility = View.VISIBLE
        }
    }

    // ---------------------------------------------------------------------------------------------
    // render player marker
    // ---------------------------------------------------------------------------------------------
    private fun renderPlayerMarker() {
        if (playerMarker == null) {
            playerMarker = ImageView(requireContext()).apply {
                setImageResource(playerTokenId)
                layoutParams = FrameLayout.LayoutParams(200, 200)
            }
            markerContainer.addView(playerMarker)
        }

        placeMarker(playerMarker!!, player.getCurrentLocation())
    }

    // ---------------------------------------------------------------------------------------------
    // render all quest markers
    // ---------------------------------------------------------------------------------------------
    private fun renderQuestMarkers() {
        // get lists of valid quests
        val active = gs.getQuestManager().getActiveQuests()
        val completed = gs.getQuestManager().getCompletedQuests()
        val validQuestIds = (active + completed).map { it.getId() }

        // remove invalid quest markers
        questMarkers.keys
            .filter { it !in validQuestIds }
            .toList()
            .forEach { removeQuestMarker(it) }

        // ensure markers
        gs.getQuestManager().getActiveQuests().forEach { quest ->
            removeQuestMarker(quest.getId())
            ensureObjectiveMarker(quest)
        }
        gs.getQuestManager().getCompletedQuests().forEach { quest ->
            removeQuestMarker(quest.getId())
            ensureRewardMarker(quest)
        }
    }

    // ---------------------------------------------------------------------------------------------
    // render particular objective marker
    // ---------------------------------------------------------------------------------------------
    private fun ensureObjectiveMarker(quest: Quest) {
        if (questMarkers.containsKey(quest.getId())) return

        val marker = ImageView(requireContext()).apply {
            setImageResource(R.drawable.mrk_objective)
            layoutParams = FrameLayout.LayoutParams(150, 150)
            setOnClickListener { showMarkerDialog(quest) }
        }

        markerContainer.addView(marker)
        placeMarker(marker, quest.getTargetLocation())

        questMarkers[quest.getId()] = marker
    }

    // ---------------------------------------------------------------------------------------------
    // render particular reward marker
    // ---------------------------------------------------------------------------------------------
    private fun ensureRewardMarker(quest: Quest) {
        if (questMarkers.containsKey(quest.getId())) return

        val marker = ImageView(requireContext()).apply {
            setImageResource(R.drawable.mrk_reward)
            layoutParams = FrameLayout.LayoutParams(150, 150)
            setOnClickListener { showMarkerDialog(quest) }
        }

        markerContainer.addView(marker)
        when (quest.getNpc()) {
            NPC.SCHOLAR -> placeMarker(marker, LocationId.LAB)
            NPC.MAYOR -> placeMarker(marker, LocationId.TOWN_HALL)
            NPC.ALCHEMIST -> placeMarker(marker, LocationId.TAVERN)
        }

        questMarkers[quest.getId()] = marker
    }

    // ---------------------------------------------------------------------------------------------
    // remove particular quest marker
    // ---------------------------------------------------------------------------------------------
    private fun removeQuestMarker(questId: String) {
        questMarkers[questId]?.let {
            markerContainer.removeView(it)
        }
        questMarkers.remove(questId)
    }

    // ---------------------------------------------------------------------------------------------
    // place marker on location
    // ---------------------------------------------------------------------------------------------
    private fun placeMarker(view: View, location: LocationId) {
        val (xPercent, yPercent) = MapPositions.positions[location]!!

        view.doOnLayout {
            val mapX = mapImage.x
            val mapY = mapImage.y

            val x = mapX + mapImage.width * xPercent - view.width / 2f
            val y = mapY + mapImage.height * yPercent - view.height / 2f

            view.x = x
            view.y = y
        }
    }

    // ---------------------------------------------------------------------------------------------
    // quest marker dialog
    // ---------------------------------------------------------------------------------------------
    private fun showMarkerDialog(quest: Quest) {
        gs.getSoundManager().playSound(R.raw.click)

        val builder = androidx.appcompat.app.AlertDialog.Builder(gs)
        val title = SpannableString(quest.getTitle())
        title.setSpan(
            ForegroundColorSpan(ContextCompat.getColor(gs, R.color.judge_gray)),
            0, title.length,
            Spannable.SPAN_INCLUSIVE_INCLUSIVE
        )
        title.setSpan(
            AbsoluteSizeSpan(resources.getDimension(R.dimen.normal_text).toInt()),
            0, title.length,
            Spannable.SPAN_INCLUSIVE_INCLUSIVE
        )
        builder.setTitle(title)
        when (quest.getState()) {
            QuestState.ACTIVE -> builder.setMessage(quest.getActiveDescription())
            QuestState.COMPLETED -> builder.setMessage(quest.getCompletedDescription())
            else -> {}
        }
        builder.setPositiveButton("Ок") { dialog, _ ->
            gs.getSoundManager().playSound(R.raw.click)
            dialog.dismiss()
        }
        val dialog = builder.create()
        dialog.show()
        dialog.findViewById<TextView>(android.R.id.message)?.apply {
            setTextColor(ContextCompat.getColor(gs, R.color.judge_gray))
            textSize = resources.getDimension(R.dimen.extra_small_text) / resources.displayMetrics.scaledDensity
        }

        dialog.getButton(AlertDialog.BUTTON_POSITIVE)?.apply {
            textSize = resources.getDimension(R.dimen.tiny_text) / resources.displayMetrics.scaledDensity
            setTextColor(ContextCompat.getColor(gs, R.color.judge_gray))
        }

        dialog.window?.setBackgroundDrawableResource(R.color.zombie)
    }
}