[안드로이드] 쥬디의 찜질방 게임 만들기 - 4. 게임 만들기 (2)

5. 손님이 이동할 수 있는 위치로 이동했을 때, 발생하는 이벤트

손님은 서비스 영역(얼음방, 불꽃방, 마사지, 라이트) 와 의자1, 의자2, 의자3에 위치할 수 있다. 손님이 원하는 서비스에 맞는 서비스 영역으로 이동했을 때, 서비스를 받을 수 있는데 서비스를 다 받는 동안 게이지로 서비스 충족도가 표시된다. 서비스를 다 받으면, 다음 서비스를 요청하거나 계산을 요청할 수 있다.

게이지로 표시되는 모습

 

EventItemControl.kt - 서비스 영역 컨트롤(프로그래스 바)

class EventItemControl(val originImage : Int, val clickImage: Int, val activity: GameActivity) {
    private val CLICK_IMAGE = 2
    private val ORIGIN_IMAGE = 1
    private var runImage = originImage
    var X = 0f
    var Y = 0f
    var width = 0F
    var height = 0F
    var isChangeImage = false
    lateinit var view: ImageView
    lateinit var progress : ProgressBar
    lateinit var handler : Handler
    var lock : Boolean = false

    fun setItemPosition(X:Float, Y:Float, width:Int, height:Int){
        this.X = X
        this.Y = Y
        this.width = width/2F
        this.height = height/2F
    }

    fun setView(view:ImageView, progress : ProgressBar, runImage : Int, handler: Handler){
        this.view = view
        this.progress = progress
        this.runImage = runImage
        this.handler = handler
    }

    //  손님이 이 서비스 영역에 있는지 없는지 판별해준다.
    fun checkItemIn(vX: Float, vY:Float) : Boolean{
        return (vX >= this.X - width && vX <= this.X + width && vY >= this.Y - height && vY <= this.Y + height)
    }

    // 손님이 이 서비스 영역에 있을 때, 앉을 수 있으면 clickImage, 앉을 수 없으면 originImage
    fun changeImage(version:Int){
        if(version == ORIGIN_IMAGE){
            view.setImageResource(originImage)
            isChangeImage = false
        } else {
            view.setImageResource(clickImage)
            isChangeImage = true
        }
    }

    // 손님이 서비스 받는 게이지를 실행해준다.
    @RequiresApi(Build.VERSION_CODES.N)
    fun progressThread(character: View, itemImageView: ImageView, num : Int, now : Int){
        // now : 현재 받을 서비스 번호 , num : 손님 번호
        character.visibility = View.GONE
        progress.setProgress(100, false)
        progress.visibility = View.VISIBLE
        view.setImageResource(runImage)
        lock = true
        Thread() {
            // 0.1초마다 5씩 줄어든다.
            var progressState = 95
            for(i in 1..20){
                try {
                    progress.setProgress(progressState, true)
                    progressState -= 5
                    Thread.sleep(100)
                } catch (E:Exception){
                    Log.d("error", E.toString())
                }
            }
            // 손님이 서비스를 다 받으면 다음엔 어떤 서비스를 받을지 선택해야한다.
            handler.post {
                character.x = activity.mCustomerExistPosition[now].x
                character.y = activity.mCustomerExistPosition[now].y
                character.visibility = View.VISIBLE
                progress.visibility = View.GONE    // 게이지는 사라진다.
                view.setImageResource(originImage)

                // 다음 서비스 선택
                activity.nextRunItem(now, num, itemImageView)
            }
            lock = false
        }.start()
    }
}

 

EventStandControl.kt - 손님이 의자에 다가갔을 때 발생하는 이벤트 관리 

class EventStandControl(val standView: ImageView) {
    val originImage : Int = R.drawable.stand
    val clickImage: Int = R.drawable.standclick
    private val CLICK_IMAGE = 2
    private val ORIGIN_IMAGE = 1
    var X = 0f
    var Y = 0f
    var width = 0F
    var height = 0F
    var isChangeImage = false

    fun setPosition(X:Float, Y:Float, width:Int, height:Int){
        this.X = X
        this.Y = Y
        this.width = width/2F
        this.height = height/2F
    }

    // 손님이 이 의자 영역에 있는지 없는지 판별해준다.
    fun checkItemIn(customerPosition: ItemPoint) : Boolean{
        // customerPosition : 손님의 현재 위치정보 - x, y, width, height
        return ((this.X >= customerPosition.x && this.X <= customerPosition.x + customerPosition.width)
                && (this.Y >= customerPosition.y && this.Y <= customerPosition.y + customerPosition.height))
        //return (vX >= this.X - width && vX <= this.X + width && vY >= this.Y - height && vY <= this.Y + height)
    }

    // 손님이 의자 영역에 있을 때, 앉을 수 있으면 clickImage, 앉을 수 없으면 originImage
    fun changeImage(version:Int){
        if(version == ORIGIN_IMAGE){
            standView.setImageResource(originImage)
            isChangeImage = false
        } else {
            standView.setImageResource(clickImage)
            isChangeImage = true
        }
    }

}

 

GameActivity.kt

/* 각 요소(서비스 : 얼음방, 불꽃방, 마사지, 라이트)에서 손님이 다가갔을 때, 서비스를 받을 수 있다는 표시인 하얀색 테두리가 있는 그림으로 바뀌거나, 손님이 서비스를 받고 있는 게이지를 나타내는 프로그레스바를 컨트롤하는 클래스 = EvenItemControl.kt 를 담고 있는 배열이다. */
lateinit var mItemControlList: ArrayList<EventItemControl>

/* 각 요소(의자1, 의자2, 의자3)에 손님이 다가갔을때, 앉을 수 있다는 표시를 해주는 것을 컨트롤하는 클래스를 담은 배열 */
lateinit var mStandControlList: ArrayList<EventStandControl>

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    mItemControlList = createItemControlList()
    mStandControlList = createStandControlList()
        
}

private fun createItemControlList() : ArrayList<EventItemControl>{
    // [0] 얼음방, [1] 불꽃방 , [2] 마사지 , [3] 라이트
    val array = ArrayList<EventItemControl>()
    array.add(EventItemControl(R.drawable.iceroom, R.drawable.iceroomclick, this))
    array.add(EventItemControl(R.drawable.fire, R.drawable.fireclick, this))
    array.add(EventItemControl(R.drawable.masa, R.drawable.masaclick, this))
    array.add(EventItemControl(R.drawable.light, R.drawable.lightclick, this))

    array[0].setView(binding.iceRoom, binding.progressIceRoom, R.drawable.iceroom, handler)
    array[1].setView(binding.fireRoom, binding.progressFireRoom, R.drawable.fire, handler)
    array[2].setView(binding.masa, binding.progressMasa, R.drawable.msasrun, handler)
    array[3].setView(binding.light, binding.progressLight, R.drawable.lightrun, handler)
    return array
}

private fun createStandControlList() : ArrayList<EventStandControl>{
    val array = ArrayList<EventStandControl>()
    array.add(EventStandControl(binding.stand1))   // 의자1
    array.add(EventStandControl(binding.stand2))   // 의자2
    array.add(EventStandControl(binding.stand3))   // 의자3
    return array
}

 

6. 쥬디의 찜질방에 오시는 손님

게임 화면에 일정시간이 지나면 손님이 오시는데 이것은 동적으로 뷰를 만들어서 표현한다. 또한, 손님이 이동중일때와 어떤 위치에 이동했을 때 발생하는 이벤트도 같이 고려한다. 손님이 서비스 영역이나 의자로 이동할 때, 이미 다른 손님이 계시거나 서비스 영역으로 이동했을 때, 원하는 서비스가 아니면 이동하지 못하고 다시 그 전의 자리로 되돌아간다. 원하는 서비스 영역에 들어갔을 경우 서비스를 받는다!! - 프로그래스 바 실행, 서비스 충족 게이지 보여줌

 

GameActivity.kt - 손님 뷰 생성

private val nPL = 10000
private val nBL = 20000
private val nRL = 30000
private val nProL = 40000
private val nIL = 50000
    
private fun createCustomer(parent: ViewGroup, num: Int, position: Int) {
    // position : 손님이 앉을 수 있는 의자 번호이다. 0 : stand1 , 1 : stand2 , 2 : stand3
    // num : 손님 번호이다.
    val itemParent = LinearLayout(this)
    itemParent.id = nPL + num
    itemParent.orientation = LinearLayout.HORIZONTAL
    itemParent.layoutParams = RelativeLayout.LayoutParams(
        ViewGroup.LayoutParams.WRAP_CONTENT,
        ViewGroup.LayoutParams.WRAP_CONTENT
    )

    val characterBody = ImageView(this)
    characterBody.id = nBL + num
    characterBody.layoutParams = LinearLayout.LayoutParams(180, 270)
    characterBody.setImageResource(R.drawable.charactersit)

    // 받을 서비스 선택 (얼음방, 불꽃방, 마사지, 라이트)
    val number = mCustomerRunControl[num].nextRun(-1)
    // 선택한 서비스의 이미지 리소스 (얼음방, 불꽃방, 마사지, 라이트, 계산)
    val res = mCustomerRunControl[num].indexToResource(number)

    // characterImage : 받을 서비스를 적용할 이미지뷰
    val characterImage = ImageView(this)
    characterImage.id = nIL + num
    characterImage.setImageResource(res)
    val characterImageLayoutParams = RelativeLayout.LayoutParams(80, 80)
    characterImageLayoutParams.topMargin = 30
    characterImageLayoutParams.marginStart = 25
    characterImage.layoutParams = characterImageLayoutParams
    characterImage.setTag(number)  // 받을 서비스 저장

    val characterTimer = ImageView(this)
    characterTimer.id = nProL + num
    characterTimer.setImageResource(R.drawable.question)
    characterTimer.setTag(0)
    val layoutParams = RelativeLayout.LayoutParams(130, 160)
    layoutParams.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE)
    characterTimer.layoutParams = layoutParams

    setCustomerOnTouchListener(itemParent, characterBody, characterImage, characterTimer, num)


    val itemRelativeLayout = RelativeLayout(this)
    itemRelativeLayout.id = nRL + num
    itemRelativeLayout.layoutParams = LinearLayout.LayoutParams(
        ViewGroup.LayoutParams.WRAP_CONTENT,
        ViewGroup.LayoutParams.WRAP_CONTENT
    )

    itemRelativeLayout.addView(characterTimer)
    itemRelativeLayout.addView(characterImage)

    itemParent.addView(characterBody)
    itemParent.addView(itemRelativeLayout)

    parent.addView(itemParent)

    // 캐릭터 위치 초기화 새로 오신 손님은 의자에만 앉아있을 수 있다. 의자는 4, 5, 6 중 하나이다.
    mCustomPosition[num] = position + 4
    mItemExistCheck[position + 4] = num
    itemParent.x = mCustomerExistPosition[position + 4].x
    itemParent.y = mCustomerExistPosition[position + 4].y
    // 손님의 서비스 충족에 대한 인내심 타이머
    customerTimerThreadStart(num, characterTimer)
}

 

GameActivity.kt - 손님의 서비스 충족에 대한 인내심 타이머

// 핸들러
lateinit var handler : Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    
    handler = Handler(Looper.getMainLooper())
}
private fun customerTimerThreadStart(num : Int, runItemValueView : ImageView){
        // num : 손님 번호
        val thread1 = Thread(){
            for(i in 1..4){
                // 8초에 한번씩 손님이 기다릴 수 있는 인내심이 떨어진다.
                // 총 3번 참을 수 있다. 4번이 되면 손님의 인내심이 바닥나고 게임은 종료된다.
                for(time in 1..80){
                    Thread.sleep(100)
                    if(mCustomPosition[num] == -1 || mfinish){
                        // 손님이 제시간내에 서비스를 다 받아서 가게를 나간 상태, 이미 손님 캐릭터도 지워졌다.
                        break
                    }
                }
                if(mCustomPosition[num] == -1 || mfinish){
                    // 손님이 제시간내에 서비스를 다 받아서 가게를 나간 상태, 이미 손님 캐릭터도 지워졌다.
                    break
                } else {
                    handler.post {
                        val questionImage = when(i){
                            1 -> R.drawable.questionone
                            2 -> R.drawable.questiontwo
                            3 -> R.drawable.questionthree
                            else -> R.drawable.question
                        }
                        runItemValueView.setImageResource(questionImage)
                        runItemValueView.setTag(i)    // 손님의 인내심 게이지가 몇단계인지 저장
                        if(mCustomPosition[num] == 2){
                            // 손님이 마사지 서비스를 받고 있을 경우 gameActivity 의 question 을 제어해야 한다.
                            binding.masaQuestion.setImageResource(questionImage)
                        }
                    }
                }

                if(mfinish) {
                    // 이미 다른 손님의 욕구를 충족시키지 못해 게임이 끝난 상태
                    break
                } else if(i == 4){
                    // 이 손님(num)의 욕구를 시간내에 충족시키지 못해 타임 오버로 게임이 종료되었다.
                    mfinish = true
                    handler.post {
                        runItemValueView.setImageResource(R.drawable.question_finish)
                        // Toast.makeText(this, "the game is over!", Toast.LENGTH_SHORT).show()
                        gameFinish()
                    }
                    break
                }
            }
        }
        thread1.start()
        // Log.d("thread", "thread state  :  ${thread1.state}")
    }

 

GameActivity.kt - 손님이 이동중 혹은 이동했을 때 발생하는 이벤트

// 손님이 마사지 서비스를 원할 경우, 마사지를 받기 전에 물 혹은 달걀을 요청할 것이다.
// 마사지 기계는 1대이므로 이 마사지 기계에 앉은 손님의 프로그레스바의 정보는 1개만 있으면 된다.
// data class SnackToProgress(val character: View, val itemImageView: ImageView, val num : Int, val service : Int)
private var snackToProgress : SnackToProgress? = null

@SuppressLint("ClickableViewAccessibility")
fun setCustomerOnTouchListener(character: View, bodyImage: ImageView, itemImage: ImageView, timerView: ImageView, num: Int){
    // num = 손님번호
    character.setOnTouchListener(View.OnTouchListener { v, event ->

        val parentWidth = (v.parent as ViewGroup).width // 부모 View 의 Width
        val parentHeight = (v.parent as ViewGroup).height // 부모 View 의 Height

        // itemImage 의 태그에는 받을 서비스의 번호가 들어있다.
        // 받을 서비스 : [-1]계산 , [0]얼음방, [1]불꽃방, [2]마사지, [3]라이트
        // 받을 서비스가 계산이면 손님은 움직이지 못한다.
        if (itemImage.getTag() != -1) {
            if (event.action == MotionEvent.ACTION_DOWN) {
                // 뷰 누름, 손님을 이동시킬때 손님은 일어서있다.
                bodyImage.setImageResource(R.drawable.characterstand)
            } else if (event.action == MotionEvent.ACTION_MOVE) {
                // 뷰 이동 중, 손님도 같이 움직여야 한다.
                v.x = v.x + event.x - v.width / 2
                v.y = v.y + event.y - v.height / 2

                // 각 요소(서비스)들의 상태 확인 (각 요소 : 0 - 얼음방, 1 - 불꽃방, 2 - 마사지, 3 - 라이트)
                // 손님이 현재 받을 수 있는 서비스에 다가가면 그 서비스는 하얀색테두리가 둘러진 그림(clickImage)으로 바뀌여야 한다.
                // 혹은 손님이 서비스 영역에 없는데도 clickImage 일 경우 originImage 로 바꿔야 한다.
                for (i in 0..3) {
                    if (mItemExistCheck[i] == -1 && mItemControlList[i].checkItemIn(v.x, v.y)) {
                        // 현재 서비스 받고 있는 손님이 없고, 서비스 영역 안에 손님이 들어가 있음
                        if (!mItemControlList[i].isChangeImage) {
                            // 손님이 서비스 영역 안에 들어가 있는데 originImage 일 경우 -> clickImage 로 바꾼다.
                            mItemControlList[i].changeImage(2)
                        }
                    } else if (mItemControlList[i].isChangeImage) {
                        // 손님이 서비스 영역 안에 뷰가 안들어가 있는데 clickImage 일 경우 -> originImage 로 바꾼다.
                        mItemControlList[i].changeImage(1)
                    }
                }
                // 손님이 의자 영역에 있으면 의자는 clickImage 로 바뀌어야 하고,
                // 손님이 의자 영역에 있지 않으면 originImage 로 바뀌어야 한다.
                for (i in 0..2) {
                    if (mItemExistCheck[i + 4] == -1 && mStandControlList[i].checkItemIn(ItemPoint(v.x, v.y, v.measuredWidth, v.measuredHeight))) {
                        // 의자에 앉아있는 손님은 없고, 의자 영역 안에 손님이 들어가 있음
                        if (!mStandControlList[i].isChangeImage) {
                            // 손님이 의자 영역 안에 들어가 있는데 originImage 일 경우 -> clickImage 로 바꾼다
                            mStandControlList[i].changeImage(2)
                        }
                    } else if (mStandControlList[i].isChangeImage) {
                        // 서비스 영역 안에 손님이 없는데 clickImage 일 경우 -> originImage
                        mStandControlList[i].changeImage(1)
                    }
                }
            } else if (event.action == MotionEvent.ACTION_UP) {
                // 뷰에서 손을 뗌
                if (v.x < 0) {
                    v.setX(0F)
                } else if (v.x + v.width > parentWidth) {
                    v.x = (parentWidth - v.width).toFloat()
                }
                if (v.y < 0) {
                    v.setY(0F)
                } else if (v.y + v.height > parentHeight) {
                    v.y = (parentHeight - v.height).toFloat()
                }

                if(mCustomPosition[num] in 0..3 && mItemControlList[mCustomPosition[num]].checkItemIn(v.x, v.y)){
                    // 손님의 원래 위치가 서비스 영역(얼음방, 불꽃방, 마사지, 라이트)이었고, 이동 후에도 그 서비스 영역이었을 경우
                    // 쥬디가 그 서비스 영역으로 이동하라는 것으로 인식한다. (쥬디는 서비스 영역(얼음방, 불꽃방, 마사지, 라이트) 을 클릭할 경우 그쪽으로 이동해야하기 때문)
                    if (indexToCheckBox(mCustomPosition[num]).visibility != ImageView.VISIBLE) {
                        judyAnimationAdd(mCustomPosition[num])
                    }
                } else {
                    var flag = false   // 손님이 위치를 이동할 수 있을 경우 : true, 위치를 이동할 수 없을 경우 : false
                    // 뷰에서 손을 땠을 때 clickImage -> originImage 로 바꾸기
                    // 손님이 서비스(얼음방, 불꽃방, 마사지, 라이트)를 받을 경우 progressbar 실행한다.
                    for (i in 0..3) {
                        if (mItemControlList[i].checkItemIn(v.x, v.y)) {
                            // 서비스 영역 안에 손님이 들어가 있음 -> 다른 서비스 검사할 필요 없음. (break)
                            if (mItemControlList[i].isChangeImage) {
                                // 손님이 서비스를 받는다!
                                mItemControlList[i].changeImage(1)  // originImage 로 바꾼다.
                                if (!mItemControlList[i].lock && itemImage.getTag() == i) {
                                    // 손님이 서비스를 받을 거기 때문에 이전에 위치했던 장소는 비어야 한다.
                                    mItemExistCheck[mCustomPosition[num]] = -1
                                    // 손님의 현재 위치를 받을 서비스 위치로 한다.
                                    mCustomPosition[num] = i
                                    // 서비스 영역에 손님이 있다는 표시를 해준다. (num) -> 없으면 -1이다.
                                    mItemExistCheck[i] = num
                                    flag = true  // 손님은 위치를 이동했다는 표시이다.
                                    if(i == 2){
                                        // 만약 손님이 마사지 서비스를 받게 되는 경우 손님은 물 혹은 달걀을 요청한다.
                                        character.visibility = View.GONE
                                        binding.masa.setImageResource(R.drawable.masaquestion)
                                        binding.masaStandQuestion.visibility = View.VISIBLE
                                        binding.masaQuestion.setImageResource(when(timerView.getTag()){
                                            1 -> R.drawable.questionone
                                            2 -> R.drawable.questiontwo
                                            3 -> R.drawable.questionthree
                                            else -> R.drawable.question
                                        })
                                        if(Random().nextInt(2) == 0) {
                                            // water = 0
                                            binding.masaQuestionValue.setImageResource(R.drawable.wateritem)
                                            binding.masaQuestionValue.setTag(0)
                                        }
                                        else {
                                            // egg = 1
                                            binding.masaQuestionValue.setImageResource(R.drawable.eggitem)
                                            binding.masaQuestionValue.setTag(1)
                                        }
                                        // 나중에 마사지 서비스를 받기 전 물 혹은 달걀 서비스를 받으면 실행될 마사지의 진행바(프로그래스바)의 정보이다.
                                        // 마사지 기계는 1대이므로 단일 변수로 저장시켜도 된다.
                                        snackToProgress = SnackToProgress(character, itemImage, num, i)
                                    }
                                    else {
                                        // 얼음방, 불꽃방, 라이트 서비스를 받게 될 경우, 바로 서비스를 받는다.
                                        // 서비스를 받는 동안 게이지가 줄어드는 표시(progressbar)를 설정한다.
                                        mItemControlList[i].progressThread(character, itemImage, num, i)
                                    }
                                }
                            }
                            break
                        }
                    }
                    // 손님이 의자 영역에 있었던 경우, 의자에 앉아있는 손님이 없었던 경우엔 의자에 앉혀야 한다.
                    if (!flag) {
                        for (k in 0..2) {
                            if (mStandControlList[k].isChangeImage && mItemExistCheck[k + 4] == -1) {
                                // 손님이 의자 영역에 있었고, 의자에 앉아있는 손님이 없었던 경우
                                // 손님을 의자에 앉힌다.
                                mStandControlList[k].changeImage(1)  // originImage 로 바꾸기
                                character.x = mCustomerExistPosition[k + 4].x
                                character.y = mCustomerExistPosition[k + 4].y
                                bodyImage.setImageResource(R.drawable.charactersit)

                                mItemExistCheck[k + 4] = num  // 이 의자에 손님이 앉았으니 손님 번호를 넣어줌
                                // 손님이 이 의자에 앉을 것이므로 이전에 있었던 곳엔 이제 아무도 없으니 -1로 공백으로 둔다.
                                mItemExistCheck[mCustomPosition[num]] = -1
                                // 손님의 현재 위치를 이 의자위치로 바꾼다.
                                mCustomPosition[num] = k + 4
                                flag = true
                                break
                            }
                        }
                    }
                    // 손님은 서비스 영역(얼음방, 불꽃방, 마사지, 라이트) 혹은 의자(1,2,3) 에만 갈 수 있다.
                    // 따라서 손님이 어중간한 장소에 놓여지거나 이미 서비스 영역 혹은 의자(1,2,3)에 먼저 온 손님이 있어
                    // 위치를 옮기지 못하는 경우, 이전에 있던 위치로 되돌아간다.
                    if (!flag) {
                        if (mCustomPosition[num] >= 4) {
                            // 손님이 이전에 있었던 곳이 의자였던 경우 앉아있는 모습으로 바꾼다.
                            bodyImage.setImageResource(R.drawable.charactersit)
                        }
                        if(mCustomPosition[num] != -1){
                            // 현재 손님이 원래 있던 곳으로 되돌아간다.
                            character.x = mCustomerExistPosition[mCustomPosition[num]].x
                            character.y = mCustomerExistPosition[mCustomPosition[num]].y
                        }
                    }
                }
            }
        } else {
            // 손님이 계산을 기다리고 있는 경우 위치를 움직이지 못한다.
            if (event.action == MotionEvent.ACTION_UP) {
                for (i in 0..3) {
                    if (mItemControlList[i].checkItemIn(v.x, v.y)) {
                        // 만약 손님이 있는 곳이 서비스 기구들(얼음방, 불꽃방, 마사지, 라이트) 영역에 있고,
                        // 손님이 계산을 기다리고 있을 경우 손님이 계신곳은 곳 서비스 기구들이고 서비스 기구들은
                        // 쥬디가 움직일 수 있는 영역 중 한 곳을 클릭한 셈이니 쥬디가 갈 경로로 추가해준다.
                        if (indexToCheckBox(i).visibility != ImageView.VISIBLE) {
                            judyAnimationAdd(i)
                        }
                        break
                    }
                }
            }
        }
        true
    })
}

 

7. 게임 시작

GameActivity.kt 

private var mCustomerNum = 100   // 쥬디의 찜질방 손님 최대 명수
private var mCustomerFinishCount = 0     // 서비스를 다 받고 계산까지 마친 손님 수
private var mCustomerStartCount = 0      // 쥬디의 찜질방에 오신 손님 수

// 손님의 요구를 시간내에 충족시키지 못할 경우 바로 게임이 끝난다.
// 게임이 끝났는지 안끝났는지 판별하는 변수
var mfinish = false    // false : 게임 안끝남 , true : 게임 끝남
lateinit var handler : Handler

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    handler = Handler(Looper.getMainLooper())
    gameStart()
}
    
// 게임을 시작한다.
private fun gameStart(){
    mCustomerStartCount = 0
    Thread(){
        while(mCustomerStartCount < mCustomerNum){
            if(mfinish){
                // 게임 종료
                break
            }
            var position = -1
            // 손님은 6초마다 한번씩 오는데 남은 의자가 있으면 가게로 손님이 들어오고 의자가 없으면 다시 8초뒤를 기다린다.
            Handler(Looper.getMainLooper()).post {
                // 손님이 올 수 있는지 체크한다. 의자1, 의자2, 의자3 에 손님이 있는지 없는지 확인한다.
                // 비어있으면 -1이므로 position 변수에 앞으로 오시는 손님의 초기위치를 정한다. (의자1, 의자2, 의자3 중 하나)
                if(mItemExistCheck[4] == -1) position = 0
                else if(mItemExistCheck[5] == -1) position = 1
                else if(mItemExistCheck[6] == -1) position = 2
                if(position != -1) {
                    // 손님이 올 수 있으면(남은 의자가 있으면) 손님을 가게로 들인다.
                    createCustomer(binding.MainParent, mCustomerStartCount, position)
                    mCustomerStartCount++
                }
            }
            Thread.sleep(6000)
        }
    }.start()
}