//private Score score; // Reference to the Score script.
void Awake()
{
// Setting up the references.
ren = transform.GetComponent<SpriteRenderer> ();
ren = transform.Find("body").GetComponent<SpriteRenderer>();
frontCheck = transform.Find("frontCheck").transform;
}
void Awake()
{
sr = GetComponent<SpriteRenderer>();
if(head == null){Debug.LogError("404: Head not found");}
headsr = head.GetComponent<SpriteRenderer>();
if(headsr == null){Debug.LogError("Head does not have a sprite renderer"); }
}
void Start()
{
sRenderer = gameObject.GetComponent<SpriteRenderer>();
sRenderer.sprite = nullSprite;
spawnPoint = gameObject.transform.position;
isSpawned = false;
}
// Use this for initialization
protected override void Start ()
{
base.Start ();
//load stats
EnemyStats stats = LevelDesign.GetEnemyStats(type);
if(stats != null)
vel = stats.vel;
isSlowed = GameController.IsSlowedDown;
vel += LevelDesign.EnemiesBonusVel;
myRigidbody2D = GetComponent<Rigidbody2D> ();
if(transform.FindChild("Sprite") != null)
spriteRenderer = transform.FindChild("Sprite").GetComponent<SpriteRenderer>();
myRigidbody2D.velocity = transform.right * vel;
if (GameController.IsSlowedDown)
ApplySlow ();
StartCoroutine (WaitForPosition ());
onEnterRangeList = new List<EventDelegate> ();
onEnterRangeList.Add (onEnterRange);
}
// Use this for initialization
void Start ()
{
currentHealth = maxHealth;
currentInvincibilityTime = maxInvincibilityTime;
rend = GetComponent<SpriteRenderer> ();
Time.timeScale = 1;
}
// Use this for initialization
void Start()
{
maxY = this.transform.position.y + .5f;
minY = maxY - 1.0f;
crateRender = this.transform.GetComponent<SpriteRenderer> ();
}
protected virtual void Start()
{
decayLevel = 0;
maxDecayLevel = DecayStates.Length;
spriteRenderer = GetComponent<SpriteRenderer>();
boxCollider = GetComponent<BoxCollider2D>();
}
// Use this for initialization
void Start () {
//必要な情報の取得
rigid = GetComponent<Rigidbody2D>();
sprite = GetComponent<SpriteRenderer>();
}
void Start ()
{
if (messageObject == null) {
messageObject = gameObject;
}
spriteRendererComp = GetComponent<SpriteRenderer> ();
}
public virtual void Init(Grid grid, int x, int y, float scale = 1, Sprite asset = null)
{
sfx = AudioManager.instance;
container = transform.Find("Sprites");
outline = transform.Find("Sprites/Outline").GetComponent<SpriteRenderer>();
img = transform.Find("Sprites/Sprite").GetComponent<SpriteRenderer>();
shadow = transform.Find("Sprites/Shadow").GetComponent<SpriteRenderer>();
shadow.gameObject.SetActive(false);
label = transform.Find("Label").GetComponent<TextMesh>();
label.GetComponent<Renderer>().sortingLayerName = "Ui";
label.gameObject.SetActive(Debug.isDebugBuild);
this.grid = grid;
this.x = x;
this.y = y;
this.asset = asset;
this.walkable = true;
transform.localPosition = new Vector3(x, y, 0);
SetAsset(asset);
SetImages(scale, Vector3.zero, 0);
SetSortingOrder(0);
visible = false;
explored = false;
}
// Use this for initialization
void Start () {
//Get a component reference to the Character's animator component
animator = GetComponent<Animator>();
render = GetComponent<SpriteRenderer>();
//Get the rigid body on the prefab
bullBody = GetComponent<Rigidbody2D>();
//Set our bullet strength and speed
strength = 4;
speed = 40;
//Go after our player!
player = GameObject.Find("Player").GetComponent<Player>();
//Get our Player current Direction
if (player.getDirection () > 0 ||
(player.getDirection() == 0 && player.getLastDirection() > 0 )) {
animator.SetInteger ("Direction", 1);
playerRight = true;
} else {
playerRight = false;
animator.SetInteger ("Direction", -1);
}
//Play our shooting sound
shoot = GameObject.Find ("Shoot").GetComponent<AudioSource> ();
shoot.Play ();
//Get our camera script
actionCamera = Camera.main.GetComponent<ActionCamera>();
}
// Use this for initialization
void Start () {
notBroken = false;
health = 0;
numBroke = 0;
Srenderer = GetComponent<SpriteRenderer>();
Srenderer.color = colors[0];
}
void Awake()
{
sprite = GetComponent<SpriteRenderer>();
body = GetComponent<Rigidbody2D>();
col = GetComponent<BoxCollider2D>();
parentBalista = transform.parent.gameObject;
}
public void Hide()
{
this.number = -1;
this.sprite.sprite = null;
mine.SetActive (false);
duang.SetActive (false);
}
public void SetNumber(int number)
{
this.number = number;
if(number != 0)
this.sprite.sprite = sprites [number];
this.sprite.color = Color.white;
}
// ================================================================
// Initialize
// ================================================================
public void Initialize (Transform _parentTransform, BGDials _bgDialsRef, CameraController _cameraControllerRef) {
bgDialsRef = _bgDialsRef;
cameraControllerRef = _cameraControllerRef;
this.transform.SetParent (_parentTransform);
spriteRenderer = GetComponent<SpriteRenderer> ();
// Just gimmie some defaults for shiggles.
lifetimeDuration = 5 * bgDialsRef.LifetimeScale;// * lifetimeDurationOnSpawnScale;
vel = Vector3.zero;
// spriteAlphaVel = 0;
diameterVel = 0;
rotationVel = 0;
parallaxScale = 0;
baseColor = Color.white;
spriteRenderer.color = baseColor;
GameUtils.SizeSprite (spriteRenderer, diameter,diameter);
// Spawn and prewarm!
Spawn ();
timeAlive = Random.Range (0, lifetimeDuration);
// Add event listeners!
// GameManagers.Instance.EventManager.CameraPosChangedEvent += OnCameraPosChanged;
// GameManagers.Instance.EventManager.CameraViewSectorChangedEvent += OnCameraViewSectorChanged;
// GameManagers.Instance.EventManager.CameraZoomChangedEvent += OnCameraZoomChanged;
}
// Use this for initialization
void Start()
{
caster = gameObject;
isEnemy = true;
spriterender = GetComponent<Renderer>() as SpriteRenderer;
player = GameObject.FindGameObjectWithTag("Player");
}
// Initialization
void Start()
{
destinationColor = color1;
destinationRotation.eulerAngles = rotation1;
spriteRenderer = GetComponent<SpriteRenderer>();
}
/*---------------------------------------------------- AWAKE ----------------------------------------------------*/
void Awake()
{
powerManager = GameObject.Find("GameManager").GetComponent<PowerManager>();
anim = transform.FindChild("Animation").GetComponent<Animator>();
effectorCollider1 = transform.FindChild("AreaEffectors").GetChild(0).GetComponent<BoxCollider2D>();
effectorCollider2 = transform.FindChild("AreaEffectors").GetChild(1).GetComponent<BoxCollider2D>();
effectorCollider3 = transform.FindChild("AreaEffectors").GetChild(2).GetComponent<BoxCollider2D>();
consoleViewImage = transform.FindChild("ConsoleView").GetComponent<SpriteRenderer>();
powerCost = GetComponent<Power>().powerCost;
GameObject fanDistance = transform.FindChild("FanDistance").gameObject;
float difference = Vector2.Distance(transform.position, fanDistance.transform.position);
effectorCollider1.size = new Vector2(difference-1, effectorCollider1.size.y);
effectorCollider1.offset = new Vector2(difference / 2, 0);
effectorCollider2.size = new Vector2(difference - 1, effectorCollider2.size.y);
effectorCollider2.offset = new Vector2(difference / 2, 1.7f);
effectorCollider3.size = new Vector2(difference - 1, effectorCollider3.size.y);
effectorCollider3.offset = new Vector2(difference / 2, -1.7f);
}
void Start()
{
target = GameObject.FindGameObjectWithTag("Player");
m_spriteRenderer = GetComponent<SpriteRenderer>();
m_playerStats = target.GetComponent<Stats> ();
m_life = m_playerStats.m_life;
}
// Use this for initialization
void Start () {
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
limits = Camera.main.ViewportToWorldPoint(Vector3.right).x -
HalfWidth;
time = shootTime;
}
// Use this for initialization
void Start () {
sprite = GetComponent<SpriteRenderer>();
scr_ObjectFactory = GameObject.FindGameObjectWithTag("ObjectFactory").GetComponent<objectFactory>();
collidingManList = new List<GameObject>();
fallDirection = new Vector3(0, -fallSpeed, 0);
}
public void init () {
// trans = transform;
// newPos = trans.localPosition;
// initX = newPos.x;
// maxX = initX + .16f;
render = GetComponent<SpriteRenderer>();
}
//private Score score; // Reference to the Score script.
void Awake()
{
// Setting up the references.
ren = transform.Find("body").GetComponent<SpriteRenderer>();
frontCheck = transform.Find("frontCheck").transform;
//score = GameObject.Find("Score").GetComponent<Score>();
}
// Use this for initialization
void Start () {
Application.targetFrameRate = 60;
if(!GlobalData.isMuted)
{
audio1.Play();
audio2.Play();
}
cTransform = GetComponent<Transform>();
time = 0;
rend = GetComponent<SpriteRenderer>();
switch(GlobalData.selectedGod)
{
case GlobalData.Gods.RHINO:
rend.sprite = SpriteManager.GetInstance().sprites["rhino_select"];
break;
case GlobalData.Gods.BEAR:
rend.sprite = SpriteManager.GetInstance().sprites["bear_select"];
break;
case GlobalData.Gods.BULL:
rend.sprite = SpriteManager.GetInstance().sprites["bull_select"];
break;
}
Camera.main.GetComponent<Shake>().ShakeCamera(0.6f, 60,60);
}
void Start()
{
_spriteRenderer = GetComponent<SpriteRenderer>();
_boxCollider = GetComponent<BoxCollider2D>();
_isLaserVisible = isLaserVisibleOnStart;
ChangeLaserApperance ();
}
void Start()
{
base.Start();
controller = GetComponent<Controller2D>();
spriteRenderer = GetComponent<SpriteRenderer>();
enemySpeed = -enemySpeed;
}
void Awake()
{
Sprite = this.gameObject.GetComponent<SpriteRenderer>();
var aleatorio = UnityEngine.Random.Range(0, 10);
if(Application.loadedLevel !=4)
{
if (aleatorio > 0 && aleatorio <= PosibilidadAcelerar)
{
PowerActual = TipoPower.Aceleracion;
Sprite.color = Color.green;
}
else if (aleatorio > PosibilidadAcelerar && aleatorio <= PosibilidadCongelar)
{
PowerActual = TipoPower.CongelarBasura;
Sprite.color = Color.blue;
}
else if (aleatorio > PosibilidadCongelar && aleatorio <= 7)
{
PowerActual = TipoPower.Proteccion;
Sprite.color = Color.gray;
}
}
if (aleatorio == 8)
{
PowerActual = TipoPower.Desacelerar;
Sprite.color = Color.red;
}
else
{
PowerActual = TipoPower.Quemar;
Sprite.color = Color.yellow;
}
}
//public GameObject box;
void Start()
{
this.GetComponent<Collider2D>().enabled = false;
Sr = this.GetComponent<SpriteRenderer>();
this.layer = Sr.sortingOrder;
top = GeneralAttrib.maxi;
}
// Use this for initialization
void Start()
{
orbitPathSpriteRenderer = this.gameObject.GetComponent<SpriteRenderer>();
//Last value is alpha value
orbitPathSpriteRenderer.color = new Color(1f, 1f, 1f, visiblePercent);
getPlanetGo ();
}
void Awake()
{
sprite = gameObject.GetComponent <SpriteRenderer>();
trigger = gameObject.GetComponent <BoxCollider2D>();
trigger.isTrigger = true;
}
public RoomData (Room room)
{
// BroadcastLights
_broadcastLightSiblingIndices = new int[room.BroadcastLights.Count];
for (int i = 0; i < room.BroadcastLights.Count; ++i)
_broadcastLightSiblingIndices[i] = room.BroadcastLights[i].transform.GetSiblingIndex();
// ReceiveLights
_receiveLightSiblingIndices = new int[room.ReceiveLights.Count];
for (int i = 0; i < room.ReceiveLights.Count; ++i)
_receiveLightSiblingIndices[i] = room.ReceiveLights[i].transform.GetSiblingIndex();
// AdjacentRooms
_adjRoomsSiblingIndices = new int[room.AdjacentRooms.Count];
for (int i = 0; i < room.AdjacentRooms.Count; ++i)
_adjRoomsSiblingIndices[i] = room.AdjacentRooms[i].transform.GetSiblingIndex();
// AlliesInRoom
_alliesInRoomSiblingIndicies = new int[room.GetAlliesInRoom().Count];
for (int i = 0; i < room.GetAlliesInRoom().Count; ++i)
if (room.GetAlliesInRoom()[i] != null)
_alliesInRoomSiblingIndicies[i] = room.GetAlliesInRoom()[i].transform.GetSiblingIndex();
// EnemiesInRoom
_enemiesInRoomSiblingIndicies = new int[room.GetEnemiesInRoom().Count];
for (int i = 0; i < room.GetEnemiesInRoom().Count; ++i)
if (room.GetEnemiesInRoom()[i] != null)
_enemiesInRoomSiblingIndicies[i] = room.GetEnemiesInRoom()[i].transform.GetSiblingIndex();
// If the room is active
_isRoomActive = room.GetIsRoomActive();
// The current light intensity
_currentLightIntensity = room.GetCurrentLightIntensity();
// If the room has been cleared
_clear = room.GetClear();
// The weight of the room
_roomWeight = room.RoomWeight;
// The type of room it is
_myRoomType = (int) room.MyRoomType;
// The difficulty of the room
_roomDifficulty = room.RoomDifficulty;
// Get the color from the spriteRenderer
SpriteRenderer sprRendRef = room.GetComponent<SpriteRenderer>();
if (sprRendRef == null)
{
Debug.LogError("No Sprite Renderer on Room " + room.name);
}
else {
_sprRendColor = new float[4];
_sprRendColor[0] = sprRendRef.color.r;
_sprRendColor[1] = sprRendRef.color.g;
_sprRendColor[2] = sprRendRef.color.b;
_sprRendColor[3] = sprRendRef.color.a;
}
// Get the position from the transform
_position = new float[3];
_position[0] = room.transform.position.x;
_position[1] = room.transform.position.y;
_position[2] = room.transform.position.z;
// Get the scale from the transform
_scale = new float[3];
_scale[0] = room.transform.localScale.x;
_scale[1] = room.transform.localScale.y;
_scale[2] = room.transform.localScale.z;
}
private void Awake()
{
_spriteRenderer = GetComponent <SpriteRenderer>();
}
private void FindRenderer(bool inbConfigure)
{
Initialize();
#if UNITY_EDITOR
if (Application.isPlaying)
{
if (m_RendererLocated)
{
return;
}
m_RendererLocated = true;
}
#else
if (m_RendererLocated)
{
return;
}
m_RendererLocated = true;
#endif // UNITY_EDITOR
if (m_Graphic)
{
return;
}
if (m_Renderer)
{
m_RendererAsSpriteRenderer = m_Renderer as SpriteRenderer;
return;
}
if (m_MaterialConfig == null)
{
m_MaterialConfig = new MaterialConfig();
}
m_Graphic = GetComponent <Graphic>();
if (m_Graphic)
{
if (inbConfigure)
{
m_Colors.Main = m_Graphic.color;
}
return;
}
m_Renderer = GetComponent <Renderer>();
if (m_Renderer)
{
m_RendererAsSpriteRenderer = m_Renderer as SpriteRenderer;
if (inbConfigure)
{
if (m_RendererAsSpriteRenderer)
{
m_Colors.Main = m_RendererAsSpriteRenderer.color;
m_MaterialConfig.MainProperty.Name = "_Color";
m_MaterialConfig.MainProperty.Enabled = false;
}
else if (m_Renderer.sharedMaterial)
{
m_Renderer.GetPropertyBlock(s_SharedPropertyBlock);
m_MaterialConfig.ConfigureForMaterial(m_Renderer.sharedMaterial);
m_Colors.Main = m_MaterialConfig.MainProperty.Retrieve(s_SharedPropertyBlock);
}
else
{
m_Renderer.GetPropertyBlock(s_SharedPropertyBlock);
m_Colors.Main = m_MaterialConfig.MainProperty.Retrieve(s_SharedPropertyBlock);
}
}
}
}
void Start()
{
animator = GetComponent<Animator>();
rb = GetComponent<Rigidbody2D>();
sr = GetComponent<SpriteRenderer>();
}
// Use this for initialization
void Start()
{
gameOver = gameObject.GetComponent <SpriteRenderer>();
source = GetComponent <AudioSource>();
restartButton.SetActive(gameOver.enabled = false);
}
// This function is called just one time by Unity the moment the component loads
private void Awake()
{
// get a reference to the SpriteRenderer component on this gameObject
mySpriteRenderer = GetComponent <SpriteRenderer>();
}
public void SetAbility(SpriteRenderer ability)
{
newAbility = ability;
newAbilityName = newAbility.sprite.name;
iconReference.sprite = Resources.Load <Sprite>("Sprites/Abilities/" + ability.sprite.name);
}
private void Awake()
{
_SpriteRenderer = GetComponent <SpriteRenderer>();
_SpriteRenderer.sprite = randomSprites[Random.Range(0, randomSprites.Count)];
}
void Awake()
{
sprd = GetComponent <SpriteRenderer>();
}
// Start is called before the first frame update
void Start()
{
lastWas = 0;
// init SpriteRenderer
sr = GetComponent<SpriteRenderer>();
}
void Start()
{
luz = GetComponent <SpriteRenderer>();
}
private void Awake()
{
rend = GetComponent <SpriteRenderer>();
main = Camera.main;
camGameObj = main.gameObject;
}
// Use this for initialization
void Start()
{
spriteRenderer = this.GetComponent <SpriteRenderer> ();
m_MaxHealth = m_Health;
}
/*
* private void OnMouseDown() {
* SpriteRenderer sp = GetComponent<SpriteRenderer>();
* sp.enabled = true;
* //Debug.Log("Clicked!");
* if (isBomb) {
* FindObjectOfType<Player>().instantDie();
* }
* }
*/
private void OnMouseOver()
{
if (Input.GetMouseButtonDown(0))
{
if (!isMarked)
{
isOpened = true;
SpriteRenderer sp = GetComponent <SpriteRenderer>();
if (isBomb)
{
sp.color = new Color(255, 0, 0);
}
sp.enabled = true;
//Debug.Log("Clicked!");
if (isBomb)
{
FindObjectOfType <Player>().instantDie();
}
}
else
{
isOpened = true;
gameObject.GetComponent <SpriteRenderer>().sprite = oldSprite;
if (!isBomb)
{
transform.localScale = new Vector3(1.5f, 0.75f, 1f);
}
else
{
transform.localScale = new Vector3(0.6f, 0.6f, 1f);
gameObject.GetComponent <SpriteRenderer>().color = new Color(255f, 0f, 0f);
FindObjectOfType <Player>().instantDie();
}
}
}
else if (Input.GetMouseButtonDown(1))
{
if (isOpened)
{
return;
}
if (!isMarked)
{
Vector3 temp = transform.localScale;
oldSprite = gameObject.GetComponent <SpriteRenderer>().sprite;
gameObject.GetComponent <SpriteRenderer>().sprite = exchangeSprite;
gameObject.GetComponent <SpriteRenderer>().enabled = true;
transform.localScale = new Vector3((0.64f), (0.64f), 1f);
isMarked = true;
//gameObject.GetComponent<SpriteRenderer>().color = new Color(255f,0,0);
}
else
{
gameObject.GetComponent <SpriteRenderer>().enabled = false;
gameObject.GetComponent <SpriteRenderer>().sprite = oldSprite;
if (!isBomb)
{
transform.localScale = new Vector3(1.5f, 0.75f, 1f);
}
isMarked = false;
}
}
}
// Start is called before the first frame update
void Start()
{
s = GetComponent <SpriteRenderer>();
health.text = "HP: " + hp;
points.text = "Score: " + score;
}
void OnEnable()
{
sprite = gameObject.GetComponent <SpriteRenderer>();
ChangeColor();
}
private void Generate(List <GameObject> objects)
{
options = new List <Menu>();
for (int i = 0; i < objects.Count; i++)
{
Menu newMenu = new Menu();
IRightClick Override = objects[i].GetComponent <IRightClick>();
if (Override == null)
{
newMenu = new Menu();
}
else
{
//newMenu = Override.MenuOverride;
newMenu.sprite = Override.MenuOverride.sprite;
newMenu.colour = Override.MenuOverride.colour;
newMenu.title = Override.MenuOverride.title;
}
if (newMenu.colour.a == 0)
{
newMenu.colour = Color.gray;
}
//newMenu.colour = Color.gray;
if (newMenu.title == null)
{
string TitleName = objects[i].name;
if (TitleName == null)
{
newMenu.title = "Unknown";
}
else
{
newMenu.title = TitleName;
}
}
if (newMenu.sprite == null)
{
SpriteRenderer UseSprite = objects[i].GetComponentInChildren <SpriteRenderer>();
if (UseSprite == null)
{
newMenu.sprite = ins.Spritenames[0];
}
else
{
newMenu.sprite = UseSprite.sprite;
}
}
//ItemAttributes ItemAttribute = objects[i].GetComponent<ItemAttributes>();
//if (ItemAttribute == null) {
//newMenu.title = "Unknown";
//} else {
//newMenu.title = ItemAttribute.itemName;
//}
//Find all monoBehaviours on object and store in a list
MonoBehaviour[] scriptComponents = objects[i].GetComponents <MonoBehaviour>();
//For each monoBehaviour in the list of script components
foreach (MonoBehaviour mono in scriptComponents)
{
Type monoType = mono.GetType();
foreach (MethodInfo method in monoType.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
var attributes = method.GetCustomAttributes(typeof(ContextMethod), true);
if (attributes.Length > 0)
{
//Logger.Log("Script: " + mono + " Method: " + method.ToString(), Category.UI);
//Logger.Log (method.ToString (), Category.UI);
bool CanPass = true;
ContextMethod contextMethodMenu =
(ContextMethod)method.GetCustomAttributes(typeof(ContextMethod), true)[0];
if (contextMethodMenu.ToCheck != null)
{
if (CheckDictionary.ContainsKey(contextMethodMenu.ToCheck))
{
if (!CheckDictionary[contextMethodMenu.ToCheck]())
{
CanPass = false;
}
}
}
if (CanPass)
{
Menu NewSubMenu = new Menu();
if (contextMethodMenu.InterColour == InterColour.Null)
{
if (contextMethodMenu.colourHex == null)
{
NewSubMenu.colour = Color.gray;
}
else
{
ColorUtility.TryParseHtmlString(contextMethodMenu.colourHex, out NewSubMenu.colour);
//NewSubMenu.colour = newCol;
}
}
else
{
ColorUtility.TryParseHtmlString(ColourDictionary[contextMethodMenu.InterColour],
out NewSubMenu.colour);
//NewSubMenu.colour = newCol;
}
if (contextMethodMenu.BGSpriteName != null)
{
//Logger.Log ("Getting set", Category.UI);
NewSubMenu.BackgroundSprite = SpriteDictionary[contextMethodMenu.BGSpriteName];
}
NewSubMenu.Item = objects[i];
NewSubMenu.title = contextMethodMenu.ButtonTitle;
NewSubMenu.sprite = SpriteDictionary[contextMethodMenu.SpriteName];
NewSubMenu.Mono = mono;
NewSubMenu.Method = method;
newMenu.SubMenus.Add(NewSubMenu);
}
}
}
}
//for (int L = 0; L < 3; L++) {
// Menu NewSubMenu = new Menu();
// NewSubMenu.colour = Color.gray;
// NewSubMenu.title = "sub " + ins.names[L];
// NewSubMenu.sprite = ins.Spritenames[0];
// newMenu.SubMenus.Add (NewSubMenu);
//}
//Sort
List <Menu> Sortlist = newMenu.SubMenus;
Menu[] array = new Menu[MenuOrder.Count + 1];
List <Menu> AddEnd = new List <Menu>();
foreach (Menu SubMenu in Sortlist)
{
if (MenuOrder.ContainsKey(SubMenu.title))
{
if (array[MenuOrder[SubMenu.title]] == null)
{
array[MenuOrder[SubMenu.title]] = SubMenu;
}
else
{
AddEnd.Add(SubMenu); //Quick fix need to think about it more
}
}
else
{
AddEnd.Add(SubMenu); //Quick fix need to think about it more
}
}
newMenu.SubMenus = new List <Menu>();
for (int S = 0; S < array.Length; S++)
{
if (!(array[S] == null))
{
newMenu.SubMenus.Add(array[S]);
}
}
newMenu.SubMenus.AddRange(AddEnd);
ins.options.Add(newMenu);
}
}
private void HighlightTileOn(int x, int y, Color color)
{
SpriteRenderer spriteRenderer = allTiles[x, y].GetComponent<SpriteRenderer>();
spriteRenderer.color = color;
}
int maxPenetrate = 1; //최대 관통 가능 횟수
void Awake()
{
renderer_ = GetComponent <SpriteRenderer>();
arrowProperty = GetComponent <ArrowProperty>();
playerProperty = GameObject.Find("PlayerTest").GetComponent <PlayerProperty>();
}
/// <summary>
/// Initialize to implement per main type.
/// </summary>
override public void Initialize()
{
// create the scene
GameScene scene = new GameScene();
// create skybox
Managers.GraphicsManager.CreateSkybox(null, scene.Root);
// create camera object
GameObject camera = new GameObject();
Camera cameraComponent = new Camera();
camera.AddComponent(cameraComponent);
cameraComponent.LookAt = new Vector3(100, 2, 100);
camera.SceneNode.Position = new Vector3(0, 5, 0);
camera.AddComponent(new CameraEditorController());
camera.Parent = scene.Root;
// create a tilemap for the floor
TileMap tilemap = scene.Root.AddComponent(new TileMap(Vector2.One * 10f, 10)) as TileMap;
// create floor material
BasicMaterial tilesMaterial = new BasicMaterial();
tilesMaterial.Texture = Resources.GetTexture("game/floor");
tilesMaterial.TextureEnabled = true;
tilesMaterial.SpecularColor = Color.Black;
// create some floor tiles
for (int i = 0; i < 10; ++i)
{
for (int j = 0; j < 10; ++j)
{
GameObject tile = tilemap.GetTile(new Point(i, j));
ShapeRenderer tileModel = tile.AddComponent(new ShapeRenderer(ShapeMeshes.Plane)) as ShapeRenderer;
tileModel.SetMaterial(tilesMaterial);
tile.SceneNode.Scale = Vector3.One * 5f;
tile.SceneNode.RotationX = (float)System.Math.PI * -0.5f;
}
}
// create random grass sprites
System.Random rand = new System.Random();
for (int i = 0; i < 100; ++i)
{
GameObject grassObj = new GameObject("grass");
grassObj.SceneNode.Scale = Vector3.One * 5;
grassObj.SceneNode.Position = new Vector3((float)rand.NextDouble() * 90f, 2.5f, (float)rand.NextDouble() * 90f);
grassObj.AddComponent(new BillboardRenderer("game/grass"));
grassObj.Parent = scene.Root;
}
// create a tree
GameObject treeObj = new GameObject("tree");
treeObj.SceneNode.Scale = Vector3.One * 30;
treeObj.SceneNode.Position = new Vector3(50, 15f, 75);
treeObj.AddComponent(new BillboardRenderer("game/tree"));
treeObj.Parent = scene.Root;
// create a spritesheet with animations (8 steps on X axis, 4 directions on Y axis)
SpriteSheet sp = new SpriteSheet(new Point(8, 4));
// add character sprite
GameObject spriteObj = new GameObject("player");
spriteObj.SceneNode.Scale = Vector3.One * 10;
spriteObj.SceneNode.Position = new Vector3(50, 5, 50);
SpriteRenderer sprite = spriteObj.AddComponent(new SpriteRenderer(sp, "game/rpg_sprite_walk")) as SpriteRenderer;
spriteObj.Parent = scene.Root;
// define walking animation and play on character
SpriteAnimationClip animationClip = new SpriteAnimationClip(startStep: 0, endStep: 7, speed: 10f, loop: true);
spriteObj.GetComponent <SpriteRenderer>().PlayAnimation(animationClip);
// set scene
GeonBitMain.Instance.Application.LoadScene(scene);
}
void Start()
{
m_Renderer = GetComponent<SpriteRenderer>();
}
void Start()
{
m_animator = GetComponent <Animator>();
m_spriteRenderer = GetComponent <SpriteRenderer>();
}
private void HighlightTileOff(int x, int y)
{
SpriteRenderer spriteRenderer = allTiles[x, y].GetComponent<SpriteRenderer>();
spriteRenderer.color = new Color(spriteRenderer.color.r, spriteRenderer.color.g, spriteRenderer.color.b, 0);
}
void Start()
{
_arrowSprite = Arrow.GetComponent <SpriteRenderer>();
}
public void Call(SpriteRenderer spriteRenderer)
{
spriteRenderer.color = Color.Value;
}
void Awake()
{
m_Sprite = GetComponent <SpriteRenderer> ();
}
/// <summary>Tweens a Material's alpha color to the given value.
/// Also stores the spriteRenderer as the tween's target so it can be used for filtered operations</summary>
/// <param name="endValue">The end value to reach</param><param name="duration">The duration of the tween</param>
public static Tweener DOFade(this SpriteRenderer target, float endValue, float duration)
{
return(DOTween.ToAlpha(() => target.color, x => target.color = x, endValue, duration)
.SetTarget(target));
}
// Start is called before the first frame update
void Start()
{
CorrectionStartAnimator = this.GetComponent <Animator>();
CorrectionRenderer = this.GetComponent <SpriteRenderer>();
CorrectionFinishScript = CorrectionFinishObj.GetComponent <CorrectionFinish>();
}
// Start is called before the first frame update
void Start()
{
spriteRenderer = gameObject.GetComponent <SpriteRenderer>();
}
