복제 게임 : 쿠키런 : 오븐 브레이크

youtu.be/4yritPZC7Vg

 

[복제 목표]

  • Unity2D가 아닌 Unity3D를 사용해서 2D 느낌을 구현
  • 1단 점프
  • 슬라이드 구현
  • 움직이는 배경 구현

[구현 설계]

  1. 캐릭터 배치 : 완료
  2. 점프, 슬라이드 버튼 배치 : 완료
  3. 캐릭터 애니메이션 제작 : 완료
  4. 버튼을 캐릭터 애니메이션과 연동 : 완료
  5. 점프 구현
    1. 점프 공식 확인 : 완료
    2. 구현 : 완료
  6. 슬라이드 구현
    1. Collider 사이즈 조정 테스트 : 완료
    2. Collider 이동 테스트 : 완료
  7. 움직이는 배경 구현
    1. 배경 리소스 확인 및 적용 : 완료
    2. 배경 움직임 구현 : 완료
  8. 버그 제거
    1. 점프 시에 슬라이드 애니메이션 돌입하지 못하도록 : 완료
    2. 점프 후에 누르고 있으면 슬라이드로 돌입하도록 : 완료
  9. 완성
  10. 타 클로닝 완료 후, 시간적 여유가 있을 경우 추가적 활동 : 진행중

[추정 소요시간] : 6H

[실제 소요시간] : 5H

 

[완성]

youtu.be/wLSpruromYo

 

블로그 이미지

RIsN

,

:: プラットフォームゲームテスト

:: 上に上がる時は衝突無視

youtu.be/hzvA86wAHAo

>>改善すべき:UpdateのたびにBoxColliderを探すのは非効率的。

using UnityEngine;

// PlayerController는 플레이어 캐릭터로서 Player 게임 오브젝트를 제어한다.
public class PlayerController : MonoBehaviour {
   public AudioClip deathClip; // 사망시 재생할 오디오 클립
   public float jumpForce = 700f; // 점프 힘

   private int jumpCount = 0; // 누적 점프 횟수
   private bool isGrounded = false; // 바닥에 닿았는지 나타냄
   private bool isDead = false; // 사망 상태

   private Rigidbody2D playerRigidbody; // 사용할 리지드바디 컴포넌트
   private Animator animator; // 사용할 애니메이터 컴포넌트
   private AudioSource playerAudio; // 사용할 오디오 소스 컴포넌트


   private void Start() {
        // 초기화
        // 게임 오브젝트로부터 사용할 컴포넌트들을 가져와 변수에 할당
        this.playerRigidbody = this.GetComponent<Rigidbody2D>();
        this.animator = this.GetComponent<Animator>();
        this.playerAudio = this.GetComponent<AudioSource>();
   }

    private Vector2 playerVelocity;
    private void Update() {
        // 사용자 입력을 감지하고 점프하는 처리
        // 사망 시 처리를 더 이상 진행하지 않고 종료
        if(isDead)
        {
            return;
        }

        this.playerVelocity = playerRigidbody.velocity;
        if(playerRigidbody.velocity.y > 0)
        {
            // :: Find all BoxCollider2D
            foreach (var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                // :: Player : Ignore it
                Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, true);
            }
        } else if(playerRigidbody.velocity.y < 0)
        {
            foreach(var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, false);
            }
        }

        // :: When Mouse Right Button Clicking
        if(Input.GetMouseButton(1))
        {
            // :: Igonore all Box Collider
            foreach (var itm in GameObject.FindObjectsOfType<BoxCollider2D>())
            {
                // :: If it's not Start Block
                if(!itm.gameObject.name.Contains("Start"))
                    Physics2D.IgnoreCollision(playerRigidbody.gameObject.GetComponent<CircleCollider2D>(), itm, true);
            }
        }

        if(Input.GetMouseButtonDown(0) && jumpCount < 2)
        {
            // 점프 횟수 증가
            jumpCount++;
            // 점프 직전에 속도를 순간적으로 제로(0, 0)로 변경
            playerRigidbody.velocity = Vector2.zero;
            // 리지드 바디에 위쪽으로 힘 주기
            playerRigidbody.AddForce(new Vector2(0, jumpForce));
            // 오디오 소스 재생
            playerAudio.Play();
        } else if(Input.GetMouseButtonUp(0) && playerRigidbody.velocity.y > 0)
        {
            // 마우스 왼쪽 버튼에서 손을 떼는 순간 && 속도의 y 값이 양수라면(위로 상승 중)
            // 현재 속도를 절반으로 변경
            playerRigidbody.velocity = playerRigidbody.velocity * 0.5f;
        }

        // 애니메이터의 Grounded 파라미터를 isGrounded 값으로 갱신
        animator.SetBool("Grounded", isGrounded);
   }

   private void Die() {
        // 사망 처리
        // 애니메이터의 Die 트리거 파라미터를 셋
        animator.SetTrigger("Die");

        // 오디오 소스에 할당된 오디오 클립을 deathClip으로 변경
        playerAudio.clip = deathClip;
        // 사망 효과음 재생
        playerAudio.Play();

        // 속도를 제로(0, 0)으로 변경
        playerRigidbody.velocity = Vector2.zero;
        // 사망 상태를 true로 변경
        isDead = true;
   }

   private void OnTriggerEnter2D(Collider2D other)
    {

        Debug.LogFormat("OnTriggerEnter2D : {0}", other.gameObject.name);

        // 트리거 콜라이더를 가진 장애물과의 충돌을 감지
        if (other.tag == "Dead" && !isDead)
        {
            // 충돌한 상대방의 태그가 Dead이며 아직 사망하지 않았다면 Die() 실행
            Die();
        }
   }

   private void OnCollisionEnter2D(Collision2D collision)
    {

        Debug.LogFormat("OnCollisionEnter2D : {0} / {1}", playerRigidbody.velocity.y, collision.contacts[0].normal.y);

        // 바닥에 닿았음을 감지하는 처리
        // 어떤 콜라이더와 닿았으며, 충돌 표면이 위쪽을 보고 있으면
        if (collision.contacts[0].normal.y > 0.7f)
        {
            // isGrounded를 true로 변경하고, 누적 점프 횟수를 0으로 리셋
            isGrounded = true;
            jumpCount = 0;
        }
   }

   private void OnCollisionExit2D(Collision2D collision) {

        Debug.LogFormat("OnCollisionExit2D : {0}", collision.gameObject.name);

        // 바닥에서 벗어났음을 감지하는 처리
        // 어떤 콜라이더에서 떼어진 경우 isGrounded를 false로 변경
        isGrounded = false;
   }
}
블로그 이미지

RIsN

,

백준 2739 : 구구단

C# 2020. 11. 24. 22:45

N을 입력받은 뒤, 구구단 N단을 출력하는 프로그램을 작성하시오. 출력 형식에 맞춰서 출력하면 된다.

첫째 줄에 N이 주어진다. N은 1보다 크거나 같고, 9보다 작거나 같다.
출력형식과 같게 N*1부터 N*9까지 출력한다.

:: 성공

: 개선점 : 없음

using System;

namespace for01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input and Parse
            int a = Int32.Parse(Console.ReadLine());

            // :: Calculate and Print
            for(int i = 1; i <= 9; i++)
            {
                Console.WriteLine("{0} * {1} = {2}", a, i, a * i);
            }
        }
    }
}

'C#' 카테고리의 다른 글

백준 2741 : N 찍기  (0) 2020.11.28
백준 15552 : 빠른 A+B  (0) 2020.11.27
백준 2753 : 윤년  (0) 2020.11.20
백준 1330 : 두 수 비교하기  (0) 2020.11.18
백준 2588 : 곱셈  (0) 2020.11.16
블로그 이미지

RIsN

,

>Durationがよく作動しない感じがする?

>もっと確認が必要。

// :: Fade Out
public System.Action CallBack_FadeOut = null; // Callback delegate
public void FadeOut(Image image)
{
	image.gameObject.SetActive(true); // :: Render TRUE
	DOTween.ToAlpha(
		() => image.color,
		alpha => image.color = alpha,
		0f, // :: Target Value
		1f) // :: Duration
		.SetEase(Ease.InQuad) // :: Set Animation Play Type
		.onComplete = () =>  // :: On Complete
		{
			this.CallBack_FadeOut?.Invoke(); // :: Call Back when this Action isn't null
			this.CallBack_FadeOut = null; // :: Reset Action
            image.gameObject.SetActive(false); // :: Render FALSE
		};
}
// :: Fade In
public System.Action CallBack_FadeIn = null; // Callback delegate
public void FadeIn(Image image)
{
    image.gameObject.SetActive(true); // :: Render TRUE
    DOTween.ToAlpha(
        () => image.color,
        alpha => image.color = alpha,
        1f, // :: Target Value
        1f) // :: Duration
        .SetEase(Ease.InQuad) // :: Set Animation Play Type
        .onComplete = () =>  // :: On Complete
        {
            this.CallBack_FadeIn?.Invoke(); // :: Call Back when this Action isn't null
            this.CallBack_FadeIn = null; // :: Reset Action
            image.gameObject.SetActive(true); // :: Render TRUE
        };
}
블로그 이미지

RIsN

,

[프로젝트명] S? : Charles VII

[장르] 전략

[목적] 스터디 전용 & 취업 포트폴리오

 

[사용 에셋]

 

 

 

 

일지 #1

<0> 시작
<1> 캐릭터 [0][0][0]에 출력
<2> 캐릭터 [1][-1][0]으로 이동 with DOTween
<3> 캐릭터 [4][-7][3]으로 이동 by AStar Algorithm

<1> 캐릭터 [0][0][0]에 출력

[A. 출력시 캐릭터 <-> 맵 상호간 오브젝트 보유]

// :: Connect Character and Tile
private void ConnectCharacterAndTile(GameObject character, GameObject tile)
{
    character.GetComponent<Battle_Class_Character>().SetTileObject(tile);
    tile.GetComponent<Battle_Class_Tile>().SetCharacterObject(character);
}

<2> 캐릭터 [1][-1][0]으로 이동 with DOTween

// :: Move Position
public void MovePosition(Vector3 position, System.Action action)
{
    // :: Rotation
    this.gameObject.transform.DOLookAt(position, ROTATION_SPEED)
        .onComplete = () =>
        {
            // :: Move
            this.gameObject.transform.DOMove(position, MOVING_SPEED)
            	.onComplete = () => { action?.Invoke(); };
    	};
}

<3> 캐릭터 [4][-7][3]으로 이동 by AStar Algorithm

[AStar Algorithm이란?]

: A* search algorithm

: 간단 설명 : 거리를 추정해서 가까운 곳 위주로 탐색해서 나아가는 알고리즘

: 참고 : よくわかるA*(A-star)アルゴリズム

: 쓰는 이유?

>> 길찾기를 할 때 쓰는 알고리즘으로 기본적인 알고리즘이라는 소문

 

youtu.be/ESLPnJmlvew

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Battle_GOFunc_Astar
{
    // :: Constructor
    public Battle_GOFunc_Astar() { }

    // :: Constant
    private int[,] DIRECTION = new int[6, 3] { { -1, 0, 1 }, { 0, -1, 1 }, { 1, -1, 0 }, { 1, 0, -1 }, { 0, 1, -1 }, { -1, 1, 0 } };

    // :: Variable : for Node
    private LinkedList<int[]> paths;
    private List<Astar_Node> listNode;
    private List<Astar_Node> listOpenNode;
    private List<Astar_Node> listClosedNode;

    // :: Initialise
    public void Init(List<Battle_Class_Tile> listTile)
    {
        // :: Use
        this.paths = new LinkedList<int[]>();
        this.listNode = new List<Astar_Node>();
        this.listOpenNode = new List<Astar_Node>();
        this.listClosedNode = new List<Astar_Node>();

        // :: Make Node and put it in list
        this.AddNodeList(listTile);
    }

    // :: Make Node
    private void AddNodeList(List<Battle_Class_Tile> listTile)
    {
        // :: Convert
        foreach (var itm in listTile)
        {
            // :: Make Node
            Astar_Node node = new Astar_Node();
            node.Init(itm.X, itm.Y, itm.Z);

            // :: Add it
            this.listNode.Add(node);
        }
    }

    // :: GET Path
    public LinkedList<int[]> GetPath(Battle_Class_Tile baseTile, Battle_Class_Tile targetTile)
    {
        // :: Set Base and Target Node
        Astar_Node baseNode = this.GetNode(baseTile.X, baseTile.Y, baseTile.Z);
        Astar_Node targetNode = this.GetNode(targetTile.X, targetTile.Y, targetTile.Z);

        // :: Find Min Path
        this.GetPathImplement(baseNode, targetNode);

        // :: Return
        return this.paths;
    }
    // :: Get Path Implement
    private void GetPathImplement(Astar_Node baseNode, Astar_Node targetNode)
    {
        // :: EXIT : Found Target
        if (baseNode == targetNode)
            return;

        // :: Status Open
        foreach (var itm in this.CheckDirectionNode(baseNode))
        {
            var openNode = itm.Open(targetNode);
            if(openNode != null)
                this.listOpenNode.Add(openNode);
        }

        // :: Find Min
        var minNode = this.FindMinCost();

        // :: Check Distance : And Turn Back When it's 2+
        this.TurnBackPath(baseNode, minNode);

        // :: Add Path
        this.paths.AddLast(new int[3] { minNode.x, minNode.y, minNode.z });

        // :: Close Min and Add Closed Node
        this.listClosedNode.Add(minNode.Closed());
        this.listOpenNode.Remove(minNode);

        // :: Return Self : When reach target Node
        this.GetPathImplement(minNode, targetNode);
    }
    // :: Turn Back Path : When distance is 2+
    private void TurnBackPath(Astar_Node baseNode, Astar_Node minNode)
    {
        // :: Check Distance and Same Distance
        var distance = this.CheckDistance(baseNode, minNode);
        var lastPathSameDistance = baseNode.estimateCost == minNode.estimateCost;

        if (distance == false)
        {
            // :: Close Base Node
            this.listClosedNode.Add(baseNode.Closed());
            this.listOpenNode.Remove(baseNode);

            // :: Delete Last Path
            this.paths.RemoveLast();

            // :: Return Path
            Astar_Node newBaseNode = this.GetNode(this.paths.Last.Value[0], this.paths.Last.Value[1], this.paths.Last.Value[2]);

            // :: Return Self : When distance <= 2 or Same Distance
            distance = this.CheckDistance(newBaseNode, minNode);
            lastPathSameDistance = newBaseNode.estimateCost == minNode.estimateCost;
            if (distance == false)
            {
                this.TurnBackPath(newBaseNode, minNode);
            }
            // :: or Same Distance
            else if (lastPathSameDistance)
            {
                // :: Close Base Node
                this.listClosedNode.Add(newBaseNode.Closed());
                this.listOpenNode.Remove(newBaseNode);

                // :: Delete Last Path
                this.paths.RemoveLast();

                Debug.LogFormat("마지막이 거리와 같을 때 {0},{1},{2} / {3},{4},{5}", newBaseNode.x, newBaseNode.y, newBaseNode.z, minNode.x, minNode.y, minNode.z);
            }
        }
        // :: or Same Distance
        else if (lastPathSameDistance)
        {
            // :: Close Base Node
            this.listClosedNode.Add(baseNode.Closed());
            this.listOpenNode.Remove(baseNode);

            // :: Delete Last Path
            this.paths.RemoveLast();

            Debug.LogFormat("마지막이 거리와 같을 때 {0},{1},{2} / {3},{4},{5}", baseNode.x, baseNode.y, baseNode.z, minNode.x, minNode.y, minNode.z);
        }
    }
    // :: Find Min Distance
    private Astar_Node FindMinCost()
    {
        // :: First Set
        Astar_Node minNode = this.listOpenNode[0];

        // :: Find
        foreach(var itm in this.listOpenNode)
        {
            if (minNode.estimateCost > itm.estimateCost)
                minNode = itm;
        }

        // :: Return
        return minNode;
    }
    // :: CheckDistance
    private bool CheckDistance(Astar_Node baseNode, Astar_Node targetNode)
    {
        var distance = Mathf.Abs(baseNode.x - targetNode.x) + Mathf.Abs(baseNode.y - targetNode.y) + Mathf.Abs(baseNode.z - targetNode.z);
        return distance <= 2;
    }

    // :: Check Direction and Return which isn't null
    private List<Astar_Node> CheckDirectionNode(Astar_Node baseNode)
    {
        // :: List Direction Node
        List<Astar_Node> listDirectionNode = new List<Astar_Node>();

        for(var i = 0; i < DIRECTION.GetLength(0); i++)
        {
            // :: Check Direction with Const
            Astar_Node node = this.GetNode(baseNode.x + DIRECTION[i,0], baseNode.y + DIRECTION[i, 1], baseNode.z + DIRECTION[i, 2]);
            if(node != null 
                && this.listOpenNode.Contains(node) == false
                && this.listClosedNode.Contains(node) == false)
            {
                listDirectionNode.Add(node);
            }
        }

        // :: Return
        return listDirectionNode;
    }
    // :: Get Node
    private Astar_Node GetNode(int x, int y, int z)
    {
        return this.listNode.Find(ele => ele.x == x && ele.y == y && ele.z == z);
    }

    // :: Node Status Enum
    private enum eNodeStatus
    {
        NONE,
        OPEN,
        CLOSED
    }
    // :: Node
    private class Astar_Node
    {
        // :: Constructor
        public Astar_Node() { }

        // :: XYZ
        public int x;
        public int y;
        public int z;

        // :: Status
        public eNodeStatus status;

        // :: Cost
        public int realCost;
        public int heuristicCost;
        public int estimateCost;

        // :: Initialise
        public void Init(int x, int y, int z)
        {
            // :: XYZ
            this.x = x;
            this.y = y;
            this.z = z;

            // :: Status
            this.status = eNodeStatus.NONE;

            // :: Cost
            this.realCost = 0;
            this.heuristicCost = 0;
            this.estimateCost = this.realCost + this.heuristicCost;
        }
        // :: Chagne Status
        public Astar_Node Open(Astar_Node targetNode)
        {
            // :: Don't Open this when Closed
            if (this.status == eNodeStatus.CLOSED)
                return null;

            // :: Open
            this.status = eNodeStatus.OPEN;

            // :: Calculate Cost
            this.realCost += 1;
            this.heuristicCost = Mathf.Abs(this.x - targetNode.x) + Mathf.Abs(this.y - targetNode.y) + Mathf.Abs(this.z - targetNode.z);
            this.estimateCost = this.realCost + this.heuristicCost;

            // :: Return this
            return this;
        }
        public Astar_Node Closed()
        {
            // :: Close
            this.status = eNodeStatus.CLOSED;

            // :: Return this
            return this;
        }
    }
}

[개선점]

>> 엄청 많음, 장애물일 때의 시험 등 여러가지 필요

>> 고려중

블로그 이미지

RIsN

,

[프로젝트명] S? : Charles VII

[장르] 전략

[목적] 스터디 전용 & 취업 포트폴리오

 

[사용 에셋]

 

 

 

 

 

일지 #0

<0> 시작
<1> Hex Grid 제작 : Cube 좌표 사용
<2> Hex Grid를 코드로 제어
<3> 캐릭터 [0][0][0]에 출력

<1> Hex Grid 제작 : Cube 좌표 사용

[Hex Grid란?]

: 사각형이 아닌 육각형으로 이루어진 맵

: 쓰는 이유?

사각형보다 전략적이라는 소문

 

[Cube 좌표란?]

: 3방향으로 나눠진 좌표

: 참고 : 배달아~ 배달 가는길 알려줘!(단호함) - 우아한형제들 기술 블로그 (woowabros.github.io)

>> x가 (+1) 되면 y가 (-1) 되는 게 조금 독특함

>> 한쪽 방향으로 진행하면 하나가 플러스 하나가 마이너스 되는 구조?

 

<1> Hex Grid 제작 : Cube 좌표 사용
<1> Hex Grid 제작 : Cube 좌표 사용

<2> Hex Grid를 코드로 제어

// :: Found All Tiles
var tiles = GameObject.FindObjectsOfType<Transform>().Where(ele => ele.gameObject.name.Contains("Tile"));

foreach (var itm in tiles)
{
    // :: Change name
    string[] tileString = itm.gameObject.name.Replace('[', ' ').Replace(']', ' ').Replace("  ", " ").Split(' ');

    // :: Init x, y, z
    int x = Int32.Parse(tileString[1]);
    int y = Int32.Parse(tileString[2]);
    int z = Int32.Parse(tileString[3]);

    // :: Make new Tile Class and Initialise
    Battle_Class_Tile tile = new Battle_Class_Tile();
    tile.Init(x, y, z);

    // :: Add List
    listTile.Add(tile);
}

Debug.LogFormat(":: [Battle:Init] All Tiles Found : {0}", listTile.Count);

<3> 캐릭터 [0][0][0]에 출력

youtu.be/0N8xmJOlGXo

 

블로그 이미지

RIsN

,

백준 2753 : 윤년

C# 2020. 11. 20. 17:13

연도가 주어졌을 때, 윤년이면 1, 아니면 0을 출력하는 프로그램을 작성하시오.

윤년은 연도가 4의 배수이면서, 100의 배수가 아닐 때 또는 400의 배수일 때이다.

예를 들어, 2012년은 4의 배수이면서 100의 배수가 아니라서 윤년이다. 1900년은 100의 배수이고 400의 배수는 아니기 때문에 윤년이 아니다. 하지만, 2000년은 400의 배수이기 때문에 윤년이다.

첫째 줄에 연도가 주어진다. 연도는 1보다 크거나 같고, 4000보다 작거나 같은 자연수이다.
첫째 줄에 윤년이면 1, 아니면 0을 출력한다.

:: 성공

: 개선점 : 수학적으로 좀 더 쉽게 없으려나? 최대공약수?

using System;

namespace If01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input
            string input = Console.ReadLine();

            // :: parsing
            int a = Int32.Parse(input);

            // :: Calculate and Result
            if(a % 4 == 0 && (a % 400 == 0 || a % 100 != 0))
            {
                Console.WriteLine(1);
            } else
            {
                Console.WriteLine(0);
            }
        }
    }
}

'C#' 카테고리의 다른 글

백준 15552 : 빠른 A+B  (0) 2020.11.27
백준 2739 : 구구단  (0) 2020.11.24
백준 1330 : 두 수 비교하기  (0) 2020.11.18
백준 2588 : 곱셈  (0) 2020.11.16
백준 10430 : 나머지  (0) 2020.11.15
블로그 이미지

RIsN

,

Portfolio:事前調律 #1

Unity 2020. 11. 19. 12:38

【チーム】

・システム構造設計

 

【個人:Auto Battle】

・問題になるSingletonのCallbackを外から中に変更。

・タイルマップをコードではなく、基本シーンに入れてスタートするとコードが貰う。

 

【現状況】

・一対多(動かない)の時以外にオートバトルが動かない。

 

youtu.be/SSnDyP6hfcs

 

블로그 이미지

RIsN

,

두 정수 A와 B가 주어졌을 때, A와 B를 비교하는 프로그램을 작성하시오.

첫째 줄에 A와 B가 주어진다. A와 B는 공백 한 칸으로 구분되어져 있다.
첫째 줄에 다음 세 가지 중 하나를 출력한다.

A가 B보다 큰 경우에는 '>'를 출력한다.
A가 B보다 작은 경우에는 '<'를 출력한다.
A와 B가 같은 경우에는 '=='를 출력한다.

:: 성공

: 개선점 : 없음

using System;

namespace If01
{
    class Program
    {
        static void Main(string[] args)
        {
            // :: Input
            string[] input = Console.ReadLine().Split(' ');

            // :: parsing
            int a = Int32.Parse(input[0]);
            int b = Int32.Parse(input[1]);

            // :: Calculate and Result
            Console.WriteLine("{0}",
                a == b ? "==" : a < b ? "<" : ">");
        }
    }
}

'C#' 카테고리의 다른 글

백준 2739 : 구구단  (0) 2020.11.24
백준 2753 : 윤년  (0) 2020.11.20
백준 2588 : 곱셈  (0) 2020.11.16
백준 10430 : 나머지  (0) 2020.11.15
백준 10869 : 사칙연산  (0) 2020.11.14
블로그 이미지

RIsN

,

Portfolio:事前検証 #1

Unity 2020. 11. 17. 17:36

レファレンスゲーム:TFT

 

チームファイト タクティクス | リーグ・オブ・レジェンドのオートバトルゲームモード - チー

チームファイト タクティクス(TFT)は、自分で作ったチームで他の7人を相手に戦うラウンド制のストラテジーゲームです。目標はひとつ──最後の一人になるまで戦い抜くこと。

teamfighttactics.leagueoflegends.com

【現段階】

事前検証:チームプロジェクトのスタート前にどこまで作れるのかを検証中

 

【今回のテスト】

オートバトル:ゲームが始まって配置が終わったら勝手に戦うオートバトルモードの実証

youtu.be/crZgdh8fvII

【改善】

大あり、整理中。

블로그 이미지

RIsN

,