public Poison(GameObject poisonedObject, float poisonDamage, float poisonTurnsLeft)
{
this.poisonDamage = poisonDamage;
this.poisonedObject = poisonedObject;
this.poisonTurnsLeft = poisonTurnsLeft;
tank = poisonedObject.GetComponent <TankController>();
}
public void RemovePlayer(TankController player)
{
if (playerRegistry.ContainsKey(player.playerIndex))
{
Remove(playerRegistry[player.playerIndex]);
}
}
private void FireIfInRange(TankController closest)
{
if ((closest.transform.position - transform.position).magnitude < firingThreshold)
{
Fire();
}
}
// Use this for initialization
void Start()
{
mySprite = GetComponentInChildren <SpriteRenderer>();
controller = GetComponent <TankController>();
switch (controller.playerNum)
{
case 1:
playerNum = Statics.Player.one;
break;
case 2:
playerNum = Statics.Player.two;
break;
case 3:
playerNum = Statics.Player.three;
break;
case 4:
playerNum = Statics.Player.four;
break;
}
isAlive = true;
respawnPos = transform.position;
currentHealth = maxHealth;
}
private ITank CreateTank(bool forPlayer, GameMode mode)
{
TankController tank = Instantiate(_tankPrefab);
var healthComponent = tank.gameObject.GetComponent <TankHealthComponent>();
var unitType = forPlayer ? GameUnitType.Player : GameUnitType.Opponent;
UnitCatalog.AddAs(healthComponent, unitType);
var inputComponent = GetTankInput(tank, forPlayer, mode);
var weapon = tank.gameObject.GetComponent <TankWeaponComponent>();
BulletManager.AddWeapon(weapon);
tank.Died += OnTankDied;
tank.Health = healthComponent;
tank.Unit = healthComponent;
tank.Input = inputComponent;
tank.Weapon = weapon;
tank.gameObject.name = string.Format("{0} tank", unitType);
tank.transform.SetParent(transform, true);
if (forPlayer)
{
_tankHealthBar.ApplyModel(tank.Model);
}
return(tank);
}
public void ActivateCharacter(TankController tankController, bool active)
{
if (active)
{
m_ActiveCharacter.ReFuel();
tankController.gameObject.GetComponentInChildren <Camera>().depth = 5;
foreach (SpriteRenderer sprite in tankController.gameObject.GetComponentsInChildren <SpriteRenderer>())
{
sprite.sortingOrder = 3;
}
tankController.gameObject.transform.rotation = Quaternion.identity;
}
else
{
tankController.gameObject.GetComponentInChildren <Camera>().depth = 0;
foreach (SpriteRenderer sprite in tankController.gameObject.GetComponentsInChildren <SpriteRenderer>())
{
sprite.sortingOrder = 1;
}
}
tankController.gameObject.GetComponent <Rigidbody2D>().freezeRotation = active;
ActivateTankControls(tankController, active);
}
internal void RecordFrag(TankController victim, TankController killer)
{
EventManager.destroyedEvent.Invoke(victim);
victim.Deaths++;
//don't reward points for same-team kills.
if (ConfigValueStore.GetBoolValue("team_mode"))
{
if (OnSameTeam(victim.Name, killer.Name))
{
return;
}
}
if (snitch != null)
{
if (snitch.GetComponent <SnitchBehaviour>().collector == victim)
{
killer.RewardSnitchPoints();
}
}
killer.AddKillPoints();
EventManager.killEvent.Invoke(killer);
}
private void Awake()
{
tankRender = transform.Find("TankRenderers");
m_collider = GetComponent <Collider>();
m_rigidbody = GetComponent <Rigidbody>();
controller = GetComponent <TankController>();
}
// Start is called before the first frame update
void Start()
{
// Set our values
renderer = GetComponent <Renderer>();
playerScript = player.GetComponent <TankController>();
renderer.material.color = startColor;
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.layer == LayerMask.NameToLayer("Tank"))
{
TankController hitTank = collision.gameObject.GetComponent <TankController>();
if (hitTank)
{
if (hitTank.GetPlayer() != tankCtrl.GetPlayer())
{
tankCtrl.ChangeWeapon();
hitTank.Kill();
}
}
Destroy(gameObject);
return;
}
currentBounce++;
if (currentBounce == maxBounce)
{
Destroy(gameObject);
}
else
{
Vector3 newDirection = Vector3.Reflect(transform.forward, collision.contacts[0].normal);
transform.rotation = Quaternion.LookRotation(newDirection, Vector3.up);
}
}
void Start()
{
playerTank = GameObject.FindGameObjectWithTag("Player").GetComponent <TankController>();
playStats = GameObject.FindGameObjectWithTag("PlayerStats").GetComponent <PlayerStats>();
maxHealth = playerTank.maxHitPoints;
if (!hasObjective2)
{
objective2Text.gameObject.SetActive(false);
objective2Toggle.gameObject.SetActive(false);
}
if (!hasObjective3)
{
objective3Text.gameObject.SetActive(false);
objective3Toggle.gameObject.SetActive(false);
}
if (!hasOptionalObjective)
{
optionalObjectiveText.gameObject.SetActive(false);
optionalObjectiveToggle.gameObject.SetActive(false);
}
}
private void Setup()
{
foreach (TeamHandler team in m_Teams)
{
// Based on the number of players chosen in the lobby screen, this will remove the tanks from the current game
if (GameManager.instance != null)
{
for (int x = team.GetTeamControllers().Length; x > GameManager.instance.teamInfos[team.Team]; x--)
{
team.GetTeamControllers()[x - 1].gameObject.GetComponent <Stats>().SetAlive(false);
team.GetTeamControllers()[x - 1].gameObject.SetActive(false);
}
}
foreach (TankController controller in team.GetTeamControllers())
{
ActivateCharacter(controller, false);
if (controller.isActiveAndEnabled)
{
IgnoreCollisionsWithOtherPlayers(controller.gameObject);
}
}
}
m_ActiveTeam = m_Teams[m_ActiveTeamIndex];
m_ActiveTeamControllers = m_ActiveTeam.GetTeamControllers();
m_ActiveTeamStats = m_ActiveTeam.GetTeamStats();
m_ActiveCharacter = m_ActiveTeamControllers[m_ActiveCharacterIndex];
ActivateCharacter(m_ActiveCharacter, true);
m_TimerCoroutine = StartCoroutine(TurnTimer.Instance.StartTimer());
TurnTimer.Instance.PauseTimer();
m_ProjectileCamera.depth = -10;
}
IEnumerator ReturnTank(TankController tankController)
{
yield return(new WaitForSeconds(5f));
tankController.Disable();
servicePoolTank.ReturnItem(tankController);
}
void Awake()
{
///Fake scripts
if (m_Tanks == null)
{
m_Tanks = new List <TankController>();
for (int i = 0; i < m_Quota; ++i)
{
//TankController controller = new TankController();
GameObject obj = Instantiate(TankPrefab) as GameObject;
obj.transform.SetParent(transform);
TankController controller = obj.GetComponent <TankController>();
//controller.PassTankManagerReference(this);
m_Tanks.Add(controller);
}
}
/// end
/// Load fish info
//if (m_FishFactory == null) {
// //m_FishFactory = new FishFactory ();
// m_FishFactory = FishFactoryRef.GetComponent<FishFactory>();
//m_FishFactory.InitFishInfo ();
//}
//m_FishFactory
/// Init Tank
//StartCoroutine(InitTank());
}
private void buttonConnectToComPort_Click(object sender, EventArgs e)
{
try
{
if (!_tankController.IsConnected)
{
_tankController = new TankController(GetPortName());
buttonConnectToComPort.Text = "Отключиться";
}
else
{
MessageBox.Show("Варианты решений:\n" +
"1.Написать отключение самому\n" +
"2.Выдернуть пульт\n",
"Не удалось отключиться от танка",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
catch
{
MessageBox.Show("Варианты решений:\n" +
"1.Проверьте подключен ли пульт\n" +
"2.Проверьте указанный порт\n" +
"3.Проверьте прошивку на пульте\n" +
"4.Проверьте зарядку на танке\n" +
"5.Если после всех пунктов танк не поехал - возможно вы гумманитарий, соболезнуем",
"Не удалось подключиться к танку",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
private TankController CreateNewTank()
{
TankModel model = new TankModel(TankType.None, 5, 100f);
TankController tank = new TankController(model, tankView);
return(tank);
}
public void NextTurn()
{
ActivateCharacter(m_ActiveCharacter, false);
do
{
if (CheckAllDead())
{
StartCoroutine(Event_GameOver(null));
}
NextCharacter();
} while (!m_ActiveTeamStats[m_ActiveCharacterIndex].IsAlive());
m_ActiveCharacter = m_ActiveTeamControllers[m_ActiveCharacterIndex];
ActivateCharacter(m_ActiveCharacter, true);
TurnTimer.Instance.ResetTimer();
if (!m_Freeplay)
{
TeamHandler lastTeam = CheckLastTeamAlive();
if (lastTeam != null)
{
StartCoroutine(Event_GameOver(lastTeam));
}
}
TurnTimer.Instance.RunTimer();
if (m_ProjectileCamera && m_ProjectileCamera.depth > 0)
{
m_ProjectileCamera.depth = 0;
}
}
public void SetPlayerCameraLookAt(TankController _player)
{
// Camera look at code
// player.playerCameraSpot.position = player.transform.position - player.transform.forward * playerZoom + Vector3.up * cameraPositionAbovePlayer;
// player.playerCameraSpot.LookAt (player.transform.position + player.transform.forward * 15.0f);
}
// Update is called once per frame
public override void Update()
{
if (TrainingRoomMain.currentGameState != TrainingRoomMain.GameState.playing)
{
return;
}
//Should do the following:
//1. Identify the closest target.
//2. Swivel the barrel to keep aim at it.
//3. Move within range.
//4. Fire
if (Sim != null && currentState != TankState.destroyed)
{
TankController closest = null;
float distance = float.MaxValue;
FindClosest(ref closest, ref distance);
if (closest != null)
{
if (closest.currentState != TankState.destroyed)
{
KeepTurretAimedAtTarget(closest);
GetInRange(closest);
}
}
}
base.Update();
}
// Start is called before the first frame update
void Start()
{
// Determine which OS the game is being run on, and set controller
// mappings accordingly.
switch (Application.platform)
{
case RuntimePlatform.OSXEditor:
case RuntimePlatform.OSXPlayer:
xAim = (tag == "Player_1" ? "x-aim-1-mac" : "x-aim-2-mac");
zAim = (tag == "Player_1" ? "z-aim-1-mac" : "z-aim-2-mac");
break;
case RuntimePlatform.WindowsEditor:
case RuntimePlatform.WindowsPlayer:
xAim = (tag == "Player_1" ? "x-aim-1-win" : "x-aim-2-win");
zAim = (tag == "Player_1" ? "z-aim-1-win" : "z-aim-2-win");
break;
default:
Debug.LogError("Mappings not setup for operating systems other than Windows or Mac OS");
break;
}
input = new Vector3();
lastRot = transform.parent.forward;
tc = GetComponentInParent <TankController>();
}
// Use this for initialization
void Start()
{
shootSound = GetComponent <AudioSource>();
score = GetComponent <TankScore>();
bulletPool = Statics.gunPool;
controller = GetComponent <TankController>();
reloadingTimer = 0;
switch (controller.playerNum)
{
case 1:
playerNum = Statics.Player.one;
break;
case 2:
playerNum = Statics.Player.two;
break;
case 3:
playerNum = Statics.Player.three;
break;
case 4:
playerNum = Statics.Player.four;
break;
}
}
private void InstantiateTank(GameObject tankPrefab, Transform[] spawnPoints)
{
GameObject newTank = Instantiate(tankPrefab);
GameObject newTankStatusBars = Instantiate(tankStatusBarsPrefab);
TankController tankController = newTank.GetComponent <TankController>();
ExternalController externalController = newTank.GetComponent <ExternalController>();
UITankStatus tankStatusBars = newTankStatusBars.GetComponent <UITankStatus>();
if (tankController != null && externalController != null && tankStatusBars != null)
{
int randomIndex = Random.Range(0, spawnPoints.Length);
Vector3 randomPosition = spawnPoints[randomIndex].position + new Vector3(Random.Range(-2f, 2f), 0, Random.Range(-2f, 2f));
newTank.transform.position = randomPosition;
newTankStatusBars.transform.SetParent(uiCanvas);
tankStatusBars.SetTank(tankController, externalController);
// disable initially
externalController.enabled = false;
tanks.Add(newTank);
}
else
{
Debug.LogError("Components not found");
}
}
// Use this for initialization
void Start()
{
bulletDelay = 0;
outOfAmmoText.gameObject.SetActive(false);
myPowerUp = new Stack <PowerUpGun>();
controller = GetComponent <TankController>();
score = GetComponent <TankScore>();
ammoFill = GameObject.Find(ImageName).GetComponent <Image>();
//Assign who this is
switch (controller.playerNum)
{
case 1:
playerNum = Statics.Player.one;
break;
case 2:
playerNum = Statics.Player.two;
break;
case 3:
playerNum = Statics.Player.three;
break;
case 4:
playerNum = Statics.Player.four;
break;
}
}
// Start is called before the first frame update
void Start()
{
thisGameManager = GameManager.thisManager;
thisShipHealth = GetComponent <TankHealth>();
thisShipPhysic = GetComponent <TankPhysic>();
thisShipController = GetComponent <TankController>();
}
private IEnumerator RoundEnding()
{
// Stop tanks from moving.
DisableTankControl();
// Clear the winner from the previous round.
m_RoundWinner = null;
// See if there is a winner now the round is over.
m_RoundWinner = GetRoundWinner();
// If there is a winner, increment their score.
if (m_RoundWinner != null)
{
m_RoundWinner.m_Wins++;
}
// Now the winner's score has been incremented, see if someone has one the game.
m_GameWinner = GetGameWinner();
// Get a message based on the scores and whether or not there is a game winner and display it.
string message = EndMessage();
m_MessageSystem.RpcUpdateMessage(message);
// Wait for the specified length of time until yielding control back to the game loop.
yield return(m_EndWait);
}
private bool CheckIfInFoV(TankController t, Transform checkAgainst)
{
if (t.turret == null)
{
return(false);
}
float distanceBetweenTanks = (t.transform.position - checkAgainst.position).magnitude;
Vector3 toTank = checkAgainst.position - t.transform.position;
toTank.Normalize();
//turret is the wrong way round, so need to use up.
float angle = Vector3.Angle(-t.turret.transform.up, toTank);
float dot = Vector3.Dot(-t.turret.transform.up, toTank);
bool isInFov = false;
if (distanceBetweenTanks < maxdistance && (Mathf.Abs(angle) < fov / 2))
{
if (dot > 0 && dot < 1)
{
isInFov = true;
}
}
return(isInFov);
}
private void ActivateTankControls(TankController tankController, bool active)
{
tankController.IsActive = active;
var weapSys = tankController.GetComponentInChildren <WeaponSystem>();
if (weapSys != null)
{
weapSys.ActivateSystem(active);
}
var aimSys = tankController.GetComponentInChildren <GenericAim>();
if (aimSys != null)
{
aimSys.ResetShot();
}
var menuSys = weaponSelect.GetComponent <WeaponSelect>();
if (menuSys != null)
{
menuSys.Interactable(active);
if (active)
{
menuSys.ChangeActiveTank();
menuSys.CloseMenu();
menuSys.DisableWeaponButtons();
}
}
}
// =================================== OVERRIDE func ===================================
#region OVERRIDE func
// override GObject
public override void OnCreateObj()
{
base.OnCreateObj();
if (m_ListTankIDs == null)
{
m_ListTankIDs = new List <string>();
}
if (m_Tanks == null)
{
m_Tanks = new List <TankController>();
if (Pre_Tank != null)
{
for (int i = 0; i < m_Quota; ++i)
{
//TankController controller = new TankController();
GameObject obj = Instantiate(Pre_Tank) as GameObject;
obj.transform.SetParent(transform);
TankController controller = obj.GetComponent <TankController>();
controller.OnCreateObj();
string id = Constant.TANK + (i + 1);
controller.SetTankID(id);
controller.SetActive(false);
//controller.PassTankManagerReference(this);
m_Tanks.Add(controller);
}
}
}
}
void CreateTank(Vector3 transform)
{
TankModel tankModel = new TankModel(10, 100f);
tankView.GetComponent <Transform>().position = transform;
TankController tank = new TankController(tankModel, tankView);
}
IEnumerator GameRules()
{
yield return(new WaitForSeconds(1));
TankController leastDelayedTank = null;
int leastDelayCount = int.MaxValue;
for (int i = 0; i < tankCount; i++)
{
GameObject go = GameObject.Find("tank" + i);
if (go == null)
{
Debug.LogError("Can't find tank. check tank is valid");
continue;
}
TankController tank = go.GetComponent <TankController>();
tankList[i].tank = tank;
tank.ShowMe();
int delay = tank.tankData.m_iDelay;
if (delay < leastDelayCount)
{
leastDelayCount = delay;
leastDelayedTank = tank;
}
yield return(new WaitForSeconds(1));
}
TurnTank(leastDelayedTank);
}
public ExplodeCommand(TankController controller, Rigidbody rigidBody, TankHealth health, GameObject explosionPrefab)
: base(controller)
{
m_IsBlocking = true;
m_RigidBody = rigidBody;
m_Health = health;
m_ExplosionPrefab = explosionPrefab;
}
void Awake()
{
_trackPoints = trackPoints;
_nodes = nodes;
_Controller = Controller;
_Body = _Controller.Body;
_motor = motor;
}
// Update is called once per frame
void Update ()
{
bool tankHit = false;
Ray r = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit h;
TankController tc = null;
if(Physics.Raycast(r,out h, 1000))
{
tc = h.collider.transform.root.GetComponent<TankController>();
if(tc == null)
{
_pos = h.point;
}
else
{
tankHit = true;
_pos = tc.transform.position;
}
}
if (tankHit == false)
{
Trail.Emit = false;
}
else
{
if(_tankBeingController != tc)
{
Trail.Emit = true;
transform.localScale = Vector3.one * TankCollisionOrbitRadius;
transform.Rotate(Vector3.up, TankCollisionRotationSpeed * Time.deltaTime);
transform.position = _pos;
}
if(Input.GetMouseButtonDown(0))
{
if (_tankBeingController != null)
_tankBeingController.InControl = false;
tc.InControl = true;
_tankBeingController = tc;
}
}
}
public void GivenATankBot()
{
_tankControllerContext.PhysicsMock = Substitute.For<IPhysics>();
var tankMock = Substitute.For<TankBase>();
InitTerrain();
InitBattlefield(tankMock);
var tankController = new TankController(_tankControllerContext.PhysicsMock, tankMock, Vector3.zero);
_tankControllerContext.TankController = tankController;
InitPhysics();
}
public ShootCommand(TankController controller,
Rigidbody rigidBody,
Rigidbody shell,
Transform fireTransform,
AudioSource shootingAudio,
AudioClip fireClip)
: base(controller)
{
m_RigidBody = rigidBody;
m_Shell = shell;
m_FireTransform = fireTransform;
m_ShootingAudio = shootingAudio;
m_FireClip = fireClip;
}
void OnGUI()
{
number = GUI.SelectionGrid(new Rect(25, 25, 150, 40*count), number, tanksName, 1);
if(curentNumber != number)
{
if(tank)
Destroy(tank.gameObject);
curentNumber = number;
tank = TankController.Instantiate(Tanks[number], PivotPoint.position, PivotPoint.rotation) as TankController;
GetComponent<MouseOrbit>().target = tank.Center;
}
GUI.Box(new Rect(0.5f*(Screen.width - 300),20,320,180),"Tank Track Simulator");
GUI.Label(new Rect(0.5f*(Screen.width - 300),40,300,140), " G-mail: [email protected] \n " + " Skype: vaghinak-srapyan" + s);
}
private void Initialize()
{
if (PlayerHolder == null)
{
Debug.LogError ("Can't play game without player prefab or holder! Please check!");
return;
}
player = GameObject.FindGameObjectWithTag ("Player");
tankController = GameObject.FindGameObjectWithTag("Player").GetComponent<TankController>();
tankController.Health.OnTankDestroyed += OnTankDestroyed;
ResetPlayerPosiotion ();
}
// Use this for initialization
void Start ()
{
enemiesManager = GameObject.Find("EnemiesManager").GetComponent<EnemiesManager>();
if(enemiesManager!=null)
{
enemiesManager.OnEnemiesCountChanged += OnEnemiesChanged;
}
tankController = GameObject.FindGameObjectWithTag("Player").GetComponent<TankController>();
if(tankController!=null)
{
tankController.Health.OnHealthChanged += OnHealtChanged;
tankController.Health.OnTankDestroyed += OnTankDestroyed;
}
}
private void Reset()
{
if(enemiesManager!=null)
{
enemiesManager.OnEnemiesCountChanged -= OnEnemiesChanged;
}
tankController = GameObject.FindGameObjectWithTag("Player").GetComponent<TankController>();
if(tankController!=null)
{
tankController.Health.OnHealthChanged -= OnHealtChanged;
tankController.Health.OnTankDestroyed -= OnTankDestroyed;
}
Time.timeScale = 1f;
}
public IEnumerator SummonPlayer(TankController player)
{
player.gameObject.SetActive(false);
player.x = x;
player.y = y;
player.SetPosition(x, y);
yield return new WaitForSeconds(1.0f);
gameObject.SetActive(true);
yield return new WaitForSeconds(1.0f);
player.gameObject.SetActive(true);
gameObject.SetActive(false);
}
private void OnDestroy()
{
mainCamera = null;
uiCamera = null;
playerDeathCountLabel = null;
enemyDeathCountLabel = null;
player = null;
if (enemyList != null)
{
enemyList.Clear();
enemyList = null;
}
if (enemySummonZoneList != null)
{
enemySummonZoneList.Clear();
enemySummonZoneList = null;
}
tileArray = null;
fileManager = null;
flag = null;
}
protected GroundTargetedCommand(Vector3 target, TankController controller)
: base(controller)
{
m_Target = target;
}
public MoveCommand(Vector3 target, TankController controller, NavMeshAgent agent)
: base(target, controller)
{
m_Agent = agent;
}
private void Awake()
{
m_Agent = GetComponent<NavMeshAgent>();
m_RigidBody = GetComponent<Rigidbody>();
m_Controller = GetComponent<TankController>();
}
void Awake()
{
_Controller = Controller;
}
void Awake()
{
_Controller = Controller;
_tracksController = tracksController;
}
private void Awake()
{
m_Controller = GetComponent<TankController>();
m_RigidBody = GetComponent<Rigidbody>();
m_Health = GetComponent<TankHealth>();
}
protected Command(TankController controller)
{
m_Controller = controller;
}
void Start()
{
controller = GetComponent<TankController> ();
}
private void DrawLevel()
{
GameObject DrawObject;
for (int j = 0; j < width; j++)
{
for (int i = 0; i < height; i++)
{
Vector3 pos = new Vector3(i, 1, -j);
switch (tileArray[i,j])
{
case TileType.MasterBlock:
DrawObject = CreateObjectPrefab("Prefabs/MasterBlock", pos);
DrawObject.GetComponent<Block>().SetCoordinates(i, j);
break;
case TileType.BreakBlock:
DrawObject = CreateObjectPrefab("Prefabs/BreakBlock", pos);
DrawObject.GetComponent<Block>().SetCoordinates(i, j);
break;
case TileType.Flag:
DrawObject = CreateObjectPrefab("Prefabs/Flag", pos);
DrawObject.GetComponent<Flag>().SetCoordinates(i, j);
flag = DrawObject.GetComponent<Flag>();
break;
case TileType.Item:
DrawObject = CreateObjectPrefab("Prefabs/Item", pos);
DrawObject.GetComponent<Item>().SetCoordinates(i, j);
item = DrawObject.GetComponent<Item>();
break;
case TileType.SummonEnemyZone:
// 탱크
EnemyAI enemy;
DrawObject = CreateObjectPrefab("Prefabs/EnemyTank", pos);
enemy = DrawObject.GetComponent<EnemyAI>();
enemy.SetCoordinates(i, j);
enemyList.Add(enemy);
// 이펙트
DrawObject = CreateObjectPrefab("Prefabs/SummonZone", pos);
DrawObject.GetComponent<SummonZone>().SetCoordinates(i, j);
enemySummonZoneList.Add(DrawObject.GetComponent<SummonZone>());
StartCoroutine(DrawObject.GetComponent<SummonZone>().SummonEnemy(enemy));
break;
case TileType.SummonPlayerZone:
// 탱크
DrawObject = CreateObjectPrefab("Prefabs/PlayerTank", pos);
player = DrawObject.GetComponent<TankController>();
player.SetPosition(i, j);
// 이펙트
DrawObject = CreateObjectPrefab("Prefabs/SummonZone", pos);
DrawObject.GetComponent<SummonZone>().SetCoordinates(i, j);
playerSummonZone = DrawObject.GetComponent<SummonZone>();
StartCoroutine(playerSummonZone.SummonPlayer(player));
break;
}
}
}
}
