public static void Draw()
{
backgroundImage.Draw();
EngineFont.DrawText(null, Classe[SelectedClasse], new Size2(450, 0), new Point(Position.X, Position.Y + 80), Color.DarkViolet, EngineFontStyle.Regular, FontDrawFlags.Center, false);
EngineFont.DrawText(null, Texto[SelectedClasse], new Rectangle(Position.X + 30, Position.Y + 90, 390, 250), Color.White, EngineFontStyle.Regular, FontDrawFlags.WordBreak);
// Desenha os botões
for (int n = 0; n < button.Length; n++)
{
button[n].Draw();
}
textbox.Draw();
textbox.DrawTextMesured();
person[0].Draw(SpriteManage.FindByID(6));
person[1].Draw(SpriteManage.FindByID(7));
person[2].Draw(SpriteManage.FindByID(9));
person[3].Draw(SpriteManage.FindByID(15));
person[4].Draw(SpriteManage.FindByID(10));
person[5].Draw(SpriteManage.FindByID(11));
person[6].Draw(SpriteManage.FindByID(12));
}
public void AttackRock()
{
// set the selection square is show
// if characters holding axe and clicked on the tree in range, then tree health is -1
if (m_Character.m_currentWeapon.m_item != ItemType.AXE)
{
return;
}
const float OFFSET = 16;
float distance = Vector2.Distance(Camera.main.WorldToScreenPoint(m_Character.transform.position), Camera.main.WorldToScreenPoint(transform.position));
MusicHandler.PlaySound(SoundType.AXE_SOUND);
m_health--;
Debug.Log("rock is attacked");
if (m_health < 0)
{
gameObject.SetActive(false);
Debug.Log("rock is destroyed");
SpriteManage.DESTROY_SPRITE(gameObject);
// generate tree log after tree is cut down
for (int i = 0; i < NUMBER_OF_STONE; i++)
{
GameObject temp = SpriteManage.CREATE_SPRITE(SpriteType.STONE);
Debug.Assert(temp);
Vector2 newPos = SpriteManage.randomAroundPoint(transform.position, 16);
temp.transform.position = newPos;
}
}
}
public override void Attack()
{
if (!m_IsPlaced)
{
return;
}
if (m_AttackDelay <= 0)
{
if (m_EnemyTarget != null)
{
if (!m_EnemyTarget.active || m_EnemyTarget.GetComponent <AI>().getHealth() <= 0)
{
m_EnemyTarget = null;
return;
}
MusicHandler.PlaySound(SoundType.SPEAR_THROW);
m_AttackDelay = DEFAULT_ATTACK_DELAY;
float angle = Mathf.Atan2(m_EnemyTarget.transform.position.y - transform.position.y, m_EnemyTarget.transform.position.x - transform.position.x);
GameObject obj = SpriteManage.CREATE_SPRITE(SpriteType.SPEAR);
Debug.Assert(obj);
obj.transform.position = transform.position;
Spear spear = obj.GetComponent <Spear>();
spear.Init(angle, ObjectSide.OUR_SIDE);
}
else
{
m_AttackDelay = 0;
}
}
}
// angle in radian
public void throwSpear(float angle)
{
if (m_Health <= 0)
{
return;
}
if (m_currentWeapon != null)
{
if (m_weaponDelay > 0)
{
return;
}
if (m_currentWeapon.m_Quantity <= 0)
{
return;
}
if (m_currentWeapon.m_item == ItemType.SPEAR)
{
m_currentWeapon.m_Quantity--;
m_Weapons.setQuantity(m_currentWeapon);
GameObject temp = SpriteManage.CREATE_SPRITE(SpriteType.SPEAR);
Spear spear = temp.GetComponent <Spear>();
spear.transform.position = transform.position;
spear.Init(angle, ObjectSide.OUR_SIDE);
MusicHandler.PlaySound(SoundType.SPEAR_THROW);
m_weaponDelay = AXE_DELAY;
if (m_currentWeapon.m_Quantity <= 0)
{
changeWeapon(0);
}
}
}
}
protected void checkHealth()
{
if (m_Health <= 0)
{
SpriteManage.DESTROY_SPRITE(gameObject);
}
}
public void AttackTree()
{
if (m_Character.m_currentWeapon.m_item != ItemType.AXE)
{
return;
}
MusicHandler.PlaySound(SoundType.AXE_SOUND);
m_health--;
Debug.Log("tree is attacked");
if (m_health < 0)
{
gameObject.SetActive(false);
Debug.Log("Tree is destroyed");
SpriteManage.DESTROY_SPRITE(gameObject);
// generate tree log after tree is cut down
for (int i = 0; i < NUMBER_OF_TREE_LOG; i++)
{
GameObject temp = SpriteManage.CREATE_SPRITE(SpriteType.TREE_LOG);
Debug.Assert(temp);
Vector2 newPos = SpriteManage.randomAroundPoint(transform.position, 16);
temp.transform.position = newPos;
}
}
}
void placeTower()
{
if (m_isPlacingTower && m_currentBuilding != null)
{
Vector2 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
m_currentBuilding.transform.position = mousePosition;
if (SpriteManage.canPlaceItem(Camera.main.WorldToScreenPoint(mousePosition), m_currentBuilding))
{
m_currentBuilding.GetComponent <SpriteRenderer>().color = new Color(1.0f, 1.0f, 1.0f, 1.0f);
// change is collider istrigger to false
m_currentBuilding.GetComponent <BoxCollider2D>().isTrigger = false;
m_currentBuilding.GetComponent <CircleCollider2D>().isTrigger = true;
m_currentBuilding.GetComponent <Tower>().m_IsPlaced = true;
m_currentBuilding = null;
m_isPlacingTower = false;
InventoryItem tower = m_Character.m_Weapons.findItem(ItemType.TOWER);
tower.m_Quantity--;
m_Character.m_Weapons.setQuantity(tower);
if (tower.m_Quantity <= 0)
{
m_Character.changeWeapon(0);
}
}
else
{
Debug.Log("cant place");
}
}
}
Collider2D findShortestEnemy(Collider2D[] colliders)
{
Debug.Assert(colliders.Length > 0);
float minDistance = 99999999;
Collider2D enemy = null;
for (int i = 0; i < colliders.Length; i++)
{
if (colliders[i].tag == "character" || colliders[i].tag == "castle" || colliders[i].tag == "tower")
{
if (colliders[i].tag == "tower")
{
Debug.Assert(false);
return(colliders[i]);
}
Vector2 enemyPos = colliders[i].gameObject.transform.position;
float distance = Vector2.Distance(enemyPos, transform.position);
if (minDistance > distance)
{
minDistance = distance;
enemy = colliders[i];
}
}
else if (colliders[i].tag == "tree" || colliders[i].tag == "stone")
{
SpriteManage.DESTROY_SPRITE(colliders[i].gameObject);
}
}
return(enemy);
}
void generateBoss()
{
if (m_CurrentWay == m_LevelManage.m_Levels.Count - 1)
{
Debug.Log("generate boss");
if (boss == null)
{
boss = SpriteManage.CREATE_SPRITE(SpriteType.FINAL_BOSS);
}
}
}
void WalkToCastle()
{
if (!GetComponent <BoxCollider2D>().isTrigger)
{
return;
}
if (SpriteManage.canPlaceItem(Camera.main.WorldToScreenPoint(transform.position), gameObject))
{
GetComponent <BoxCollider2D>().isTrigger = false;
}
m_EnemyTarget = m_Castle.gameObject;
}
void Update()
{
if (mainGame.m_IsPause)
{
return;
}
m_TimeActive -= Time.deltaTime;
if (m_TimeActive <= 0)
{
SpriteManage.DESTROY_SPRITE(gameObject);
}
}
public override void Attack()
{
float distance = Vector2.Distance(transform.position, m_EnemyTarget.transform.position);
calculateAttackDistance();
if (transform.position.x > m_EnemyTarget.transform.position.x)
{
m_Facing = FACING_LEFT;
}
else
{
m_Facing = FACING_RIGHT;
}
// if in attack range then attack
if (distance < m_AttackDistance)
{
if (m_AttackDelay <= 0)
{
MusicHandler.PlaySound(SoundType.RED_ENEMY_ATTACK);
m_AttackDelay = DEFAULT_ATTACK_SPEED;
AI ai = m_EnemyTarget.GetComponent <AI>();
ai.setHealth(ai.getHealth() - m_Damage);
if (ai.getHealth() <= 0)
{
m_EnemyTarget = null;
}
}
}
else
{
float angle = Mathf.Atan2(m_EnemyTarget.transform.position.y - transform.position.y, m_EnemyTarget.transform.position.x - transform.position.x);
Vector2 newPos = transform.position;
newPos.x += Mathf.Cos(angle) * MOVING_SPEED * Time.fixedDeltaTime;
newPos.y += Mathf.Sin(angle) * MOVING_SPEED * Time.fixedDeltaTime;
transform.position = newPos;
}
if (m_Health <= 0)
{
// generate heart for player to gain health
float ran = Random.Range(0, 101);
if (Debug.isDebugBuild)
{
ran = 80;
}
if (ran >= 70)
{
var heart = SpriteManage.CREATE_SPRITE(SpriteType.HEART);
heart.transform.position = transform.position;
}
}
checkHealth();
}
public override void Attack()
{
if (m_EnemyTarget != null)
{
if (!m_EnemyTarget.active)
{
m_EnemyTarget = null;
return;
}
float distance = Vector2.Distance(transform.position, m_EnemyTarget.transform.position);
calculateAttackDistance();
if (distance < m_AttackDistance)
{
if (m_AttackDelay <= 0)
{
MusicHandler.PlaySound(SoundType.RED_ENEMY_ATTACK);
m_AttackDelay = DEFAULT_ATTACK_DELAY;
if (m_EnemyTarget.tag == "tree")
{
m_EnemyTarget.GetComponent <Tree>().m_health--;
if (m_EnemyTarget.GetComponent <Tree>().m_health <= 0)
{
SpriteManage.DESTROY_SPRITE(m_EnemyTarget);
m_EnemyTarget = null;
}
}
else if (m_EnemyTarget.tag == "stone")
{
m_EnemyTarget.GetComponent <Rock>().m_health--;
if (m_EnemyTarget.GetComponent <Rock>().m_health <= 0)
{
SpriteManage.DESTROY_SPRITE(m_EnemyTarget);
m_EnemyTarget = null;
}
}
}
}
// moving to the target
else
{
float angle = Mathf.Atan2(m_EnemyTarget.transform.position.y - transform.position.y, m_EnemyTarget.transform.position.x - transform.position.x);
Vector2 pos = transform.position;
pos.x += Mathf.Cos(angle) * MOVE_SPEED * Time.fixedDeltaTime;
pos.y += Mathf.Sin(angle) * MOVE_SPEED * Time.fixedDeltaTime;
transform.position = pos;
}
}
}
void generateEater()
{
GameLevel level = m_LevelManage.m_Levels[m_CurrentWay];
if (m_ReoucesEaterGenerateTime <= 0)
{
if (level.m_NumberOfEater > 0)
{
level.m_NumberOfEater--;
GameObject eater = SpriteManage.CREATE_SPRITE(SpriteType.RESOURCE_EATER);
Vector2 pos = SpriteManage.RandomPos();
eater.transform.position = pos;
}
m_ReoucesEaterGenerateTime = DEFAULT_RESOURCE_EATER_TIME;
}
}
void Start()
{
Debug.Assert(m_Axe);
Debug.Assert(m_Spear);
Debug.Assert(m_Sword);
m_inventory = new Inventory();
m_Craft = new CraftingEngine();
m_Weapons = new WeaponManage();
m_Weapons.addNewWeapon(new InventoryItem(ItemType.AXE));
m_Craft.m_Inventory = m_inventory;
m_Craft.m_Weapons = m_Weapons;
m_facing = FACING_RIGHT;
changeWeapon(0);
// initialize
m_HealthSystemOBJ = SpriteManage.getNewHealth();
m_HealthSystemOBJ.SetActive(true);
Debug.Assert(m_HealthSystemOBJ);
initHealth(DEFAULT_HEALTH);
spr = GetComponent <SpriteRenderer>();
m_currentAnimation = 0;
m_currentFrame = 0;
m_state = IDLE;
m_cam = Camera.main;
m_weaponDelay = 0;
m_Side = ObjectSide.OUR_SIDE;
// get uihandler
GameObject i = GameObject.Find("Inventory");
Debug.Assert(i);
m_UIhandler = i.GetComponent <UIHandler>();
Debug.Assert(m_UIhandler);
//m_DefaultWeaponAngle = m_currentWeaponSprite.transform.eulerAngles.z;
}
private static void DrawPlayer(int index, int x)
{
if (string.IsNullOrEmpty(PlayerData[index].Name))
{
return;
}
if (PlayerData[index].Sprite <= 0)
{
return;
}
EngineCore.SpriteDevice.Begin(SpriteFlags.AlphaBlend);
EngineCore.SpriteDevice.Draw(SpriteManage.FindByID(PlayerData[index].Sprite), new ColorBGRA(255, 255, 255, PlayerData[index].Transparency), new Rectangle(128, 0, 32, 32), new Vector3(0, 0, 0), new Vector3(position.X + 94 + x, position.Y + 110, 0));
EngineCore.SpriteDevice.End();
EngineFont.DrawText(null, PlayerData[index].Name, new Size2(127, 134), new Point(position.X + 49 + x, position.Y + 30), Color.DarkViolet, EngineFontStyle.Regular, FontDrawFlags.Center);
EngineFont.DrawText(null, PlayerData[index].Class, new Size2(127, 134), new Point(position.X + 49 + x, position.Y + 100), Color.Coral, EngineFontStyle.Regular, FontDrawFlags.Center);
EngineFont.DrawText(null, "Lv. " + PlayerData[index].Level, new Size2(127, 134), new Point(position.X + 49 + x, position.Y + 120), Color.RoyalBlue, EngineFontStyle.Regular, FontDrawFlags.Center);
}
void FixedUpdate()
{
if (mainGame.m_IsPause)
{
return;
}
if (!m_Arrived)
{
float angle = Mathf.Atan2(m_Castle.transform.position.y - transform.position.y, m_Castle.transform.position.x - transform.position.x);
Vector2 pos = transform.position;
pos.x += Mathf.Cos(angle) * MOVE_SPEED * Time.fixedDeltaTime;
pos.y += Mathf.Sin(angle) * MOVE_SPEED * Time.fixedDeltaTime;
transform.position = pos;
}
else
{
m_TimeRespawnEnemy -= Time.fixedDeltaTime;
if (m_TimeRespawnEnemy <= 0)
{
if (m_NumberEnemies > 0)
{
m_TimeRespawnEnemy = RESPAWN_TIME;
m_NumberEnemies--;
Vector2 castlePos = m_Castle.transform.position;
Vector2 currentPos = transform.position;
float angle = Mathf.Atan2(castlePos.y - currentPos.y, castlePos.x - currentPos.x);
float offset = m_Wall.GetComponent <BoxCollider2D>().size.x;
currentPos.x += Mathf.Cos(angle) + offset;
currentPos.x += Mathf.Sin(angle) + offset;
GameObject enemy = SpriteManage.CREATE_SPRITE(SpriteType.RED_ENEMY);
enemy.transform.position = currentPos;
}
// delete the boat
else
{
SpriteManage.DESTROY_SPRITE(gameObject);
}
}
}
checkHealth();
}
void OnTriggerEnter2D(Collider2D col)
{
GameObject temp = col.gameObject;
if (temp.tag == "treeLog")
{
SpriteManage.DESTROY_SPRITE(temp);
m_inventory.addNewItem(ItemType.WOOD);
}
else if (temp.tag == "stoneItem")
{
SpriteManage.DESTROY_SPRITE(temp);
m_inventory.addNewItem(ItemType.STONE);
}
else if (temp.tag == "heart")
{
SpriteManage.DESTROY_SPRITE(temp);
m_Health += DEFAULT_HEART_HEALTH;
}
}
void prepareTowerToPlace()
{
// cancel placing tower
if (m_isPlacingTower)
{
// if the placing tower still active, then cancel it
if (m_currentBuilding != null)
{
SpriteManage.DESTROY_SPRITE(m_currentBuilding);
m_currentBuilding = null;
}
m_isPlacingTower = false;
}
// start placing tower
else
{
m_isPlacingTower = true;
m_currentBuilding = SpriteManage.CREATE_SPRITE(SpriteType.TOWER);
}
}
void moveTowerWithMouse()
{
if (m_isPlacingTower && m_currentBuilding != null)
{
m_currentBuilding.GetComponent <BoxCollider2D>().isTrigger = true;
m_currentBuilding.GetComponent <CircleCollider2D>().isTrigger = true;
Vector2 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
m_currentBuilding.transform.position = mousePosition;
if (SpriteManage.canPlaceItem(Camera.main.WorldToScreenPoint(mousePosition), m_currentBuilding))
{
m_currentBuilding.GetComponent <SpriteRenderer>().color = new Color(1, 1, 1, .5f);
Debug.Log("can place");
}
else
{
m_currentBuilding.GetComponent <SpriteRenderer>().color = new Color(1, 0, 0, .5f);
Debug.Log("cannt place");
}
}
}
void FixedUpdate()
{
if (mainGame.m_IsPause)
{
return;
}
m_AttackDelay -= Time.fixedDeltaTime;
if (m_EnemyTarget == null)
{
m_EnemyTarget = GameObject.Find("castle");
Debug.Assert(m_EnemyTarget);
}
if (SpriteManage.canPlaceItem(Camera.main.WorldToScreenPoint(transform.position), gameObject))
//if (m_timeToTurnOnBoundingBox <= 0)
{
GetComponent <BoxCollider2D>().isTrigger = false;
}
Attack();
ChangeFacingDirection();
}
// Update is called once per frame
void Update()
{
if (mainGame.m_IsPause)
{
return;
}
m_AttackDelay -= Time.fixedDeltaTime;
if (m_AttackDelay <= 0)
{
m_AttackDelay = 0;
}
//checkHealth();
if (m_VisibleTime <= 0)
{
SpriteManage.DESTROY_SPRITE(gameObject);
}
m_VisibleTime -= Time.deltaTime;
findEnemy();
updateHealthBar();
checkHealth();
}
void generateAttackableBoat()
{
if (m_LevelManage.m_Levels[m_CurrentWay].m_NumberOfAttackableBoat <= 0)
{
return;
}
m_LevelManage.m_Levels[m_CurrentWay].m_NumberOfAttackableBoat--;
GameObject castle = GameObject.Find("castle");
GameObject obj = SpriteManage.CREATE_SPRITE(SpriteType.ATTACKABLE_BOAT);
// random angle
float angle = Random.Range(0, Mathf.PI * 2);
Debug.Log("angle boat: " + angle);
float distance = 10;
int wallRan = (int)Random.Range(0, 4);
Vector3 offset = Random.insideUnitCircle * 30;
Vector3 newpos = offset + GameObject.Find("castle").transform.position;
bool generate = false;
while (!generate)
{
generate = true;
offset = Random.insideUnitCircle * 30;
newpos = offset + GameObject.Find("castle").transform.position;
Collider2D[] list = Physics2D.OverlapBoxAll(newpos, obj.GetComponent <SpriteRenderer>().bounds.size, 0);
for (int i = 0; i < list.Length; i++)
{
Collider2D collider = list[i];
if (collider.tag == "castle")
{
generate = false;
}
}
}
obj.transform.position = newpos;
}
public override void Attack()
{
Vector2 newPos = transform.position;
Vector2 origin = m_Castle.transform.position;
float radius = Vector2.Distance(transform.position, origin);
m_CurrentAngle += ANGLE_MOVE * Time.fixedDeltaTime;
newPos.x = origin.x + Mathf.Cos(m_CurrentAngle) * radius;
newPos.y = origin.y + Mathf.Sin(m_CurrentAngle) * radius;
transform.position = newPos;
if (m_AttackDelay <= 0)
{
m_AttackDelay = DEFAULT_ATTACK_DELAY;
if (m_EnemyTarget != null)
{
var s = SpriteManage.CREATE_SPRITE(SpriteType.SPEAR);
var spear = s.GetComponent <Spear>();
float attackAngle = Mathf.Atan2(m_EnemyTarget.transform.position.y - newPos.y, m_EnemyTarget.transform.position.x - newPos.x);
spear.transform.position = transform.position;
spear.Init(attackAngle, ObjectSide.ENEMY_SIDE);
MusicHandler.PlaySound(SoundType.SPEAR_THROW);
}
}
}
void OnTriggerEnter2D(Collider2D colldier)
{
if (colldier.GetType() == typeof(CircleCollider2D))
{
return;
}
GameObject obj = colldier.gameObject;
AI ai = obj.GetComponent <AI>();
if (ai)
{
if (ai.m_Side == m_Side)
{
return;
}
ai.setHealth(ai.getHealth() - m_Damage);
Debug.Log("update enemy health: " + ai.getHealth());
SpriteManage.DESTROY_SPRITE(gameObject);
}
else
{
}
}
public override void Attack()
{
if (m_EnemyTarget == null)
{
if (m_Character.m_Health > 0)
{
m_EnemyTarget = m_Character.gameObject;
}
else
{
m_EnemyTarget = m_Castle.gameObject;
}
}
if (m_EnemyTarget != null)
{
if (!m_EnemyTarget.active)
{
m_EnemyTarget = null;
return;
}
float distance = Vector2.Distance(m_EnemyTarget.transform.position, transform.position);
// attack
if (distance <= ATTACK_RANGE)
{
if (m_UltimateAttack <= 0)
{
for (int i = 0; i < MAX_SPEAR; i++)
{
GameObject spear = SpriteManage.CREATE_SPRITE(SpriteType.SPEAR);
float angle = i * 45 * Mathf.Deg2Rad;
Spear s = spear.GetComponent <Spear>();
s.Init(angle, ObjectSide.ENEMY_SIDE);
s.m_speed = 9;
spear.transform.position = transform.position;
}
m_UltimateAttack = DEFAULT_ULTIMATE;
return;
}
if (m_AttackDelay <= 0)
{
MusicHandler.PlaySound(SoundType.SPEAR_THROW);
if (m_Health < DEFAULT_HEALTH / 2)
{
m_AttackDelay = ATTACK_DELAY_PERIOD_2;
}
else
{
m_AttackDelay = ATTACK_DELAY_PERIOD_1;
}
GameObject spear = SpriteManage.CREATE_SPRITE(SpriteType.SPEAR);
float angle = Mathf.Atan2(m_EnemyTarget.transform.position.y - transform.position.y, m_EnemyTarget.transform.position.x - transform.position.x);
Spear s = spear.GetComponent <Spear>();
s.Init(angle, ObjectSide.ENEMY_SIDE);
s.m_speed = 9;
spear.transform.position = transform.position;
}
}
else
{
// update position
float angle = Mathf.Atan2(m_EnemyTarget.transform.position.y - transform.position.y, m_EnemyTarget.transform.position.x - transform.position.x);
Vector2 newPos = transform.position;
newPos.x += Mathf.Cos(angle) * DEFAULT_MOVE_SPEED * Time.fixedDeltaTime;
newPos.y += Mathf.Sin(angle) * DEFAULT_MOVE_SPEED * Time.fixedDeltaTime;
transform.position = newPos;
}
}
}
// generate resources
void generateResouces()
{
if (m_LevelManage.m_Levels[m_CurrentWay].m_TotalResouces < 0)
{
return;
}
if (m_CurrentGenerateTreeTimeStep < 0)
{
m_CurrentGenerateTreeTimeStep = m_LevelManage.m_Levels[m_CurrentWay].m_ReseoucesInterval;
Debug.Log("generate resouces");
m_LevelManage.m_Levels[m_CurrentWay].m_TotalResouces--;
int chanceWood = m_LevelManage.m_Levels[m_CurrentWay].m_ChanceWood;
int ran = (int)Random.Range(0, 101);
GameObject ob = null;
if (ran <= chanceWood)
{
ob = SpriteManage.CREATE_SPRITE(SpriteType.TREE);
}
else
{
ob = SpriteManage.CREATE_SPRITE(SpriteType.ROCK);
}
bool generated = false;
// number of attem for item generate
int attemp = 10;
while (!generated && attemp > 0)
{
//generated = true;
Vector2 pos = SpriteManage.RandomPos();
var colliders = Physics2D.OverlapBoxAll(pos, ob.GetComponent <SpriteRenderer>().bounds.size, 0);
if (colliders.Length == 0)
{
generated = true;
}
else
{
for (int i = 0; i < colliders.Length; i++)
{
Collider2D collider = colliders[i];
Debug.Log("collider tag: " + collider.tag);
Debug.Log("type: " + collider.GetType());
if (collider.GetType() == typeof(BoxCollider2D))
{
generated = false;
}
else if (collider.GetType() == typeof(CircleCollider2D))
{
if (collider.tag == "castle")
{
generated = true;
}
}
}
}
if (generated)
{
ob.transform.position = pos;
}
attemp--;
}
Debug.Log("generated: " + generated);
if (!generated)
{
SpriteManage.DestroyObject(ob);
}
}
}
