Пример #1
0
 private void makeGrid(Vector3 begin, Vector3 end)
 {
     LineRenderer line = new GameObject().AddComponent<LineRenderer>();
     line.transform.parent = this.transform.parent;
     line.SetWidth(0.01F, 0.01F);
     line.SetColors(lightBlue, lightBlue);
     line.SetPosition(0, begin);
     line.SetPosition(1, end);
     line.SetVertexCount(2);
     line.material = new Material(Shader.Find("Particles/Additive"));
 }
Пример #2
0
    private void MakeLine(Networkable a, Networkable b)
    {
        var dir = -Camera.main.transform.forward;

        var line = new GameObject("Line").AddComponent<LineRenderer>();
        line.transform.parent = transform;
        line.SetWidth(0.4f, 0.4f);
        line.SetPosition(0, a.transform.position + dir * 7);
        line.SetPosition(1, b.transform.position + dir * 7);
        line.sharedMaterial = NodeMaterial;
    }
 internal static void MoveDown(GameObject sim, float meters)
 {
     sim.SetPosition(
         new Vector3(
             sim.Position.x,
             sim.Position.y - meters,
             sim.Position.z));
 }
 internal static void MoveBackward(GameObject sim, float meters)
 {
     sim.SetPosition(
         new Vector3(
             sim.Position.x - (sim.ForwardVector.x * meters),
             sim.Position.y,
             sim.Position.z - (sim.ForwardVector.z * meters)));
 }
    void DrawOnMove()
    {
        //Se os valores X ou Y da variavel MouseLastPosition(Posiçao antiga do mouse) forem diferentes dos valores X ou Y da variavel MouseActualPosition(Posiçao atual do mouse), entao o mouse se moveu
        if(MouseLastPosition.x != MouseActualPosition.x || MouseLastPosition.y != MouseActualPosition.y)
        {
            LineRenderer Line = new GameObject("Line").AddComponent<LineRenderer>();
            Line.transform.parent = GameObject.Find("LineMother").transform;
            Line.material = LineColor;
            Line.SetVertexCount(2);
            Line.SetWidth(0.1f,0.1f);
            Line.SetPosition(0,Camera.main.ScreenToWorldPoint(new Vector3(MouseLastPosition.x, MouseLastPosition.y, ZPosition)));
            Line.SetPosition(1,Camera.main.ScreenToWorldPoint(new Vector3(MouseActualPosition.x, MouseActualPosition.y, ZPosition)));

            //Igualando a posiçao antiga do mouse com a atual, para caso ele se mova de novo, a comparaçao seja correta
            MouseLastPosition = Input.mousePosition;
        }
    }
 internal static void MoveForward(GameObject sim, float meters)
 {
     sim.SetPosition(
         new Vector3(
             sim.Position.x + (sim.ForwardVector.x * meters),
             sim.Position.y,
             sim.Position.z + (sim.ForwardVector.z * meters)));
 }
 internal static void MoveUp(GameObject sim, float meters)
 {
     sim.SetPosition(
         new Vector3(
             sim.Position.x,
             sim.Position.y + meters,
             sim.Position.z));
 }
Пример #8
0
        public void TransferSlotFrom(GameSlot src)
        {
            Child    = src.Child;
            Contents = src.Contents;
            src.EmptySlot();

            Child.SetPosition(PyroGameManager.GetSlotLocation(X, Y));
        }
    public void VisualizeChildren2D <T>(TreeNode <T> CurrentNode, List <TreeNode <T> > waiting)
    {
        int   amountOfChildren = CurrentNode.Children.Count;
        int   currentChild     = 0;
        float radius           = 0.5F;

        foreach (TreeNode <T> node in CurrentNode.Children)
        {
            var angle     = currentChild * Mathf.PI * 2 / amountOfChildren;
            var Yposition = Mathf.Cos(angle) * radius * (_depth - CalculateDepthOfNode(node));
            var Zposition = Mathf.Sin(angle) * radius * (_depth - CalculateDepthOfNode(node));
            var pos       = CurrentNode.Node.Obj.transform.position + new Vector3(-1F, Yposition, Zposition);

            GameObject obj = Instantiate(prefab, pos, Quaternion.identity);
            drawValue(obj, 1, node.Value.ToString());
            obj.name  = "Node" + amountOfChildren.ToString();
            node.Name = "Node" + amountOfChildren.ToString();
            Debug.Log("Drawn node " + node.Value + " at " + obj.transform.position + " with depth " + CalculateDepthOfNode(node));
            node.Node = new Node(prefab, obj);

            var lineRenderer = new GameObject("Line").AddComponent <LineRenderer>();
            lineRenderer.startColor    = Color.black;
            lineRenderer.endColor      = Color.black;
            lineRenderer.startWidth    = 0.01f;
            lineRenderer.endWidth      = 0.01f;
            lineRenderer.positionCount = 2;
            lineRenderer.useWorldSpace = true;

            lineRenderer.SetPosition(0, node.Parent.Node.Obj.transform.position);
            lineRenderer.SetPosition(1, pos);

            currentChild++;
        }
        List <TreeNode <T> > range = CurrentNode.Children.ToList();

        foreach (TreeNode <T> node in range)
        {
            waiting.Add(node);
        }
        waiting.Remove(CurrentNode);
        if (waiting.Count > 0)
        {
            VisualizeChildren2D(waiting[0], waiting);
        }
    }
Пример #10
0
 public static void ParentToSlot(GameObject obj, Slot slot, GameObject parent)
 {
     if (obj != null && parent != null)
     {
         obj.SetPosition(parent.GetPositionOfSlot(slot));
         obj.SetForward(parent.GetForwardOfSlot(slot));
         obj.ParentToSlot(parent, slot);
     }
 }
    protected override void InitializeSettings(GameObject fire)
    {
        fire.SetPosition(position.IndexRow, position.IndexColumn);
        fire.transform.rotation = Quaternion.Euler(0, (Int32)rotation, 0);
        var bangLineSetting = fire.GetComponent <BangLineSettings>();

        bangLineSetting.direction = GetDirection();
        bangLineSetting.distance  = distance;
        bangLineSetting.duration  = duration;
    }
Пример #12
0
        public void SetPositionHelperInitializesThePositionVectorOfTheTransform()
        {
            var gameObject  = new GameObject();
            var newPosition = new Vector2(100, 100);

            gameObject.SetPosition(newPosition);
            var transform = gameObject.GetComponent <Transform>();

            Assert.AreEqual(newPosition, transform.Position);
        }
Пример #13
0
    public override void Execute()
    {
        //look upon me and despair
        Actor a = new GameObject("player actor", typeof(Actor)).GetComponent <Actor>();

        a.Initialize(Resources.Load <ActorTemplate>("ActorTemplates/player").Instantiate(), 0);
        a.SetPosition(_position ?? Grid.GetRandom(TileStatus.Vacant));

        GlobalEvents.Raise(GlobalEvent.ActorAdded, a);
    }
Пример #14
0
    public override void Execute()
    {
        NPActor a = new GameObject("", typeof(NPActor)).GetComponent <NPActor>();

        a.Initialize(_template.Instantiate(), 1);
        a.gameObject.name = a.data.name;
        a.SetPosition(_position ?? Grid.GetRandom(TileStatus.Vacant));

        GlobalEvents.Raise(GlobalEvent.ActorAdded, a);
    }
Пример #15
0
    /*
     * private void Start()
     * {
     *  shootLaserFrom(new Vector3(0, 0, 0), new Vector3(0, 0, 2), 2);
     * }
     */

    public void shootLaserFrom(Vector3 from, Vector3 direction, float length, Material mat = null)
    {
        LineRenderer lr = new GameObject().AddComponent <LineRenderer>();

        lr.widthMultiplier = _lineWidthMultiplier;

        // Set Material
        lr.material = mat == null ? _laserMaterial : mat;

        Ray     ray = new Ray(from, direction);
        Vector3 to  = from + length * direction;

        // Use this code when hit on mesh surface
        //RaycastHit hit;
        //if(Physics.Raycast(ray, out hit, length))
        //    to = hit.point;

        lr.SetPosition(0, from);
        lr.SetPosition(1, to);
    }
Пример #16
0
        public void TransformTest1()
        {
            var obj = new GameObject();

            Assert.AreEqual(obj.Transform, obj.Transform.GameObject.Transform.GameObject.Transform);
            var pos = new Vec3(4, 8, 7);

            obj.SetPosition(pos);
            Assert.AreEqual(obj.Transform, obj.Transform.GameObject.Transform);
            Assert.AreEqual(pos, obj.Transform.GameObject.Transform.Position);
        }
Пример #17
0
	public static void buildLine(Vector3 start, Vector3 end){
		LineRenderer line = new GameObject ("Line").AddComponent<LineRenderer> ();
		//apparently I should use this as a default material, but it didn't work so I used some arbitrary material
		//line.material = new Material(Shader.Find("Particles/Additive"));
		line.material = material;
		line.gameObject.layer = LayerMask.NameToLayer ("Minimap");
		line.material.SetColor ("colour", Color.black);
		line.castShadows = false;
		line.receiveShadows = false;
		line.transform.parent = GameObject.Find("lines").transform;
		line.SetWidth(1.0f, 1.0f);
		line.SetVertexCount(2);
		line.SetPosition(0, start);
		line.SetPosition (1, end);
		string positions = start.x.ToString () + "," + start.y.ToString () + "," + start.z.ToString () + "," + end.x.ToString () + "," + end.y.ToString () + "," + end.z.ToString ();
		if (Network.isServer) {
			ClientNetwork client = (ClientNetwork) GameObject.FindObjectOfType(typeof(ClientNetwork));
			client.startClientLines (positions);
		}
	}
Пример #18
0
    private void InitializeMap(DynamicGameObject gameFloorTemplate)
    {
        GameObject gameFloor = gameFloorTemplate.Create();
        Single     offsetByX = (Int32)(Width / 2.0);
        Single     offsetByZ = (Int32)(Length / 2.0);

        gameFloor.SetPosition(offsetByX, offsetByZ);
        var floorNetworkSettings = gameFloor.GetComponent <FloorNetworkSettings>();

        floorNetworkSettings.SetScale(Width, Length);
        floorNetworkSettings.UpdateScale();
    }
Пример #19
0
 public Line(Vector3 StartPosition, float Size)
 {
     line = new GameObject("Hihi").AddComponent <LineRenderer>();
     Vector3[] a = new Vector3[2];
     positionStart = StartPosition;
     a[0]          = positionStart;
     a[1]          = positionStart;
     line.SetPositions(a);
     line.SetPosition(0, Vector3.zero);
     line.SetWidth(Size, Size);
     line.transform.position = StartPosition;
 }
Пример #20
0
    public void connect()
    {
        if (startObj == null || endObj == null)
        {
            return;
        }
        LineRenderer lineRenderer = new GameObject("Line").AddComponent <LineRenderer>();

        lineRenderer.startColor    = Color.black;
        lineRenderer.endColor      = Color.black;
        lineRenderer.startWidth    = 0.01f;
        lineRenderer.endWidth      = 0.01f;
        lineRenderer.positionCount = 2;
        lineRenderer.useWorldSpace = true;

//For drawing line in the world space, provide the x,y,z values
        lineRenderer.SetPosition(0, startObj.transform.position); //x,y and z position of the starting point of the line
        lineRenderer.SetPosition(1, endObj.transform.position);   //x,y and z position of the starting point of the line
        startObj = null;
        endObj   = null;
    }
        public void Redo()
        {
            if (MovedObjects != null)
            {
                for (int i = 0; i < MovedObjects.Count; i++)
                {
                    GameObject currentObject = MovedObjects[i];

                    currentObject.SetPosition(NewPositions[i]);
                }
            }
        }
Пример #22
0
        public GameObject SpawnFuel(float positionX, float positionY)
        {
            int type = (int)PyroGameObjectTypes.Fuel;

            GameObject result = mGameObjectPool.Allocate();

            result.SetPosition(positionX, positionY);
            result.ActivationRadius      = mActivationRadiusTight;
            result.width                 = 32;
            result.height                = 32;
            result.PositionLocked        = true;
            result.DestroyOnDeactivation = false;

            result.life = 1;
            result.team = GameObject.Team.NONE;

            FixedSizeArray <BaseObject> staticData = GetStaticData(type);

            if (staticData == null)
            {
                ContentManager content = sSystemRegistry.Game.Content;
                GraphicsDevice device  = sSystemRegistry.Game.GraphicsDevice;

                int staticObjectCount = 1;
                staticData = new FixedSizeArray <BaseObject>(staticObjectCount);

                const int fileImageSize = 64;
                Rectangle crop          = new Rectangle(0, 0, fileImageSize, fileImageSize);
                Texture2D texture       = content.Load <Texture2D>(@"pics\fuel");


                DrawableTexture2D textureDrawable = new DrawableTexture2D(texture, (int)result.width, (int)result.height);
                textureDrawable.SetCrop(crop);

                RenderComponent render = (RenderComponent)AllocateComponent(typeof(RenderComponent));
                render.Priority = PyroSortConstants.FUEL;
                render.setDrawable(textureDrawable);

                staticData.Add(render);
                SetStaticData(type, staticData);
            }

            LifetimeComponent lifetime = AllocateComponent <LifetimeComponent>();

            lifetime.SetDeathSound(fuelSound);

            result.Add(lifetime);

            AddStaticData(type, result, null);

            return(result);
        }
Пример #23
0
    void Start()
    {
        var lineRenderer = new GameObject("LineRenderer", typeof(LineRenderer)).GetComponent <LineRenderer>();

        lineRenderer.positionCount = 160;
        lineRenderer.material      = new Material(Shader.Find("Hidden/Internal-Colored"));
        lineRenderer.endWidth      = lineRenderer.startWidth = 0.03f;

        for (int i = 0; i < 160; i++)
        {
            lineRenderer.SetPosition(i, CalcPos(i * 2f / 160));
        }
    }
Пример #24
0
    void DrawDerivative()
    {
        for (int i = 0; i < DERIVATIVE_SEGMENT_COUNT; i++)
        {
            LineRenderer lRend = new GameObject().AddComponent <LineRenderer>() as LineRenderer;

            Vector3 vertex = GetPoint(i / (float)DERIVATIVE_SEGMENT_COUNT);

            lRend.SetVertexCount(2);
            lRend.SetPosition(0, vertex);
            lRend.SetPosition(1, vertex + GetDirection(i / (float)DERIVATIVE_SEGMENT_COUNT) * DerivativeLength);

            //lRend.material.color = Color.green;
            Material myMaterial3 = (Material)Resources.Load("ArrowAsset/MyRed", typeof(Material));
            lRend.material = myMaterial3;



            derivativeLines.Add(lRend);
            derivativeLines[i].enabled = true;
        }
    }
Пример #25
0
        /// <summary>
        /// Called when behaviour enters the Playing state.
        /// For instant-fire behaviours, this is where 99% of the logic will go.
        /// </summary>
        protected override void OnEnteredPlaying(TriggeredState prevState)
        {
            SetParentTransform();
            SetLocationTransform();

            GameObject gameObj = GameObject.Instantiate(objectToInstantiate);

            gameObj.SetPosition(locationTransform.position);
            gameObj.transform.SetParent(parentTransform);

            //	Called at end of this method for an instant-fire behaviour
            RequestComplete();
        }
Пример #26
0
    void Start()
    {
        Build();
        var lineRenderer = new GameObject("LineRenderer", typeof(LineRenderer)).GetComponent <LineRenderer>();

        lineRenderer.positionCount = NumKeys;
        lineRenderer.material      = new Material(Shader.Find("Hidden/Internal-Colored"));
        lineRenderer.endWidth      = lineRenderer.startWidth = 0.03f;

        for (int i = 0; i < NumKeys; i++)
        {
            lineRenderer.SetPosition(i, CalcPos(DistanceToT(i * DistanceStepSize)));
        }
    }
Пример #27
0
        /// <summary>
        /// Draw a new line.
        /// </summary>
        /// <param name="group">Group name to associate the line with.</param>
        /// <param name="start">Starting location.</param>
        /// <param name="end">Ending location.</param>
        /// <param name="color">Color of the line.</param>
        /// <param name="size">Width of the line.</param>
        public static void AddLine(string group, Vector3 start, Vector3 end, Color color, float size)
        {
            GameObject   groupObject = AddOrGetGroup(group);
            LineRenderer lineR       = new GameObject()
            {
                name  = "Line",
                layer = layerIgnoreRaycast
            }.AddComponent <LineRenderer>();
            var matPropBlock = new MaterialPropertyBlock();

            matPropBlock.SetColor(ShaderProperty.MainColor, color);
            lineR.SetVertexCount(2);
            lineR.SetPosition(0, start);
            lineR.SetPosition(1, end);
            lineR.SetWidth(size, size);
            lineR.material = ResourceList.getInstance().Materials.PlainColor;
            lineR.SetColors(color, color);

            lineR.transform.parent = groupObject.transform;

            SetMatPropBlock(lineR, color);
            DisableShadows(lineR);
        }
        public void Undo()
        {
            if (MovedObjects != null)
            {
                for (int i = 0; i < MovedObjects.Count; i++)
                {
                    GameObject currentObject = MovedObjects[i];

                    Console.WriteLine("undo");

                    currentObject.SetPosition(OldPositions[i]);
                }
            }
        }
Пример #29
0
        public void SpawnLevelTiles()
        {
            foreach (GameSlot slot in tileSlots)
            {
                GameObjectManager     manager = sSystemRegistry.GameObjectManager;
                PyroGameObjectFactory factory = (PyroGameObjectFactory)sSystemRegistry.GameObjectFactory;

                GameObject tile = factory.SpawnTileEmpty(0, 0);
                manager.Add(tile);

                slot.Setup(GameSlotStatus.Empty, null);

                tile.SetPosition(GetSlotLocation(slot.Position));
            }
        }
Пример #30
0
 private void DrawPathLines()
 {
     if (pathLinesTransform != null)
     {
         GameObject.Destroy(pathLinesTransform.gameObject);
     }
     pathLinesTransform = new GameObject("PathLines").transform;
     foreach (var pathLine in pathLines)
     {
         LineRenderer lineRenderer = new GameObject("Line").AddComponent <LineRenderer>();
         lineRenderer.transform.SetParent(pathLinesTransform, false);
         Material material = new Material(Shader.Find("Unlit/Color"));
         material.color        = Color.yellow;
         lineRenderer.material = material;
         var start  = pathLine.startPoint.ToVector3();
         var end    = new Vector3(start.x + pathLine.deltaX, start.y + pathLine.deltaY, start.z + pathLine.deltaZ);
         var center = Vector3.Lerp(start, end, 0.5f);
         lineRenderer.SetPosition(0, start - center);
         lineRenderer.SetPosition(1, end - center);
         lineRenderer.transform.position = center;
         lineRenderer.widthMultiplier    = 0.2f;
         lineRenderer.useWorldSpace      = false;
     }
 }
Пример #31
0
    void DrawCurtain()
    {
        for (int i = 0; i < CURTAIN_SEGMENT_COUNT; i++)
        {
            LineRenderer lRend = new GameObject().AddComponent <LineRenderer>() as LineRenderer;

            Vector3 vertex = GetPoint(i / (float)CURTAIN_SEGMENT_COUNT);

            lRend.SetVertexCount(2);
            lRend.SetPosition(0, vertex);

            Vector3 vertex2 = new Vector3(vertex.x, 0, vertex.z);
            lRend.SetPosition(1, vertex2);

            //lRend.material.Color = Color.red;
            Material myMaterial2 = (Material)Resources.Load("ArrowAsset/MyRed", typeof(Material));
            lRend.material = myMaterial2;



            curtainLines.Add(lRend);
            curtainLines[i].enabled = true;
        }
    }
    GameObject Spawn()
    {
        GameObject GetRandomPrefab() => spawnPrefabs.Count > 0 ? spawnPrefabs[Random.Range(0, spawnPrefabs.Count)] : null;

        GameObject prefab   = GetRandomPrefab();
        GameObject instance = Instantiate(prefab);

        Vector3 randomPos = GetRandomPosition(radius, transform.position.y);

        instance.SetPosition(randomPos);
        instance.transform.parent = transform;

        spawnedEnemies.Add(instance);

        return(instance);
    }
Пример #33
0
        private void AdjustFPVWeapon()
        {
            if (fpvWeapon == null)
            {
                return;
            }

            Vector3 offset = HelperRotation.RotateVector(this.GetLookAtVector(), -90, Plane.Y);

            offset.Y *= 2f;
            offset.Z *= 0.5f;
            offset.X *= 0.5f;

            fpvWeapon.SetPosition(this.Position + this.GetLookAtVector() * 0.25f + offset * 0.01f);
            fpvWeapon.SetRotation(this.Rotation);
        }
Пример #34
0
        public GameObject SpawnBackgroundPlate(float positionX, float positionY)
        {
            const int  width  = 1280;
            const int  height = 720;
            int        type   = (int)PyroGameObjectTypes.Background_Plate;
            GameObject result = mGameObjectPool.Allocate();

            result.SetPosition(positionX, positionY);
            result.ActivationRadius = mActivationRadiusExtraWide;
            result.width            = width;
            result.height           = height;

            ContentManager content = sSystemRegistry.Game.Content;

            FixedSizeArray <BaseObject> staticData = GetStaticData(type);

            if (staticData == null)
            {
                const int staticObjectCount = 1;
                staticData = new FixedSizeArray <BaseObject>(staticObjectCount);

                //InventoryRecord addWin = new InventoryRecord();
                //addWin.winCount = 1;

                //staticData.Add(addWin);

                SetStaticData(type, staticData);
            }

            Rectangle         crop            = new Rectangle(0, 0, width, height);
            DrawableTexture2D textureDrawable = new DrawableTexture2D(content.Load <Texture2D>(@"pics\background"), (int)result.width, (int)result.height);

            textureDrawable.SetCrop(crop);

            RenderComponent render = (RenderComponent)AllocateComponent(typeof(RenderComponent));

            render.Priority = PyroSortConstants.BACKGROUND;
            render.setDrawable(textureDrawable);


            result.Add(render);

            //AddStaticData(type, result, null);

            return(result);
        }
Пример #35
0
    //
    // Make child GameObject with UI RectTransform on parent
    //
    public static GameObject MakeUiObject(this GameObject parent,
                                          string name = null)
    {
        GameObject    child         = new GameObject();
        RectTransform rectTransform = child.AddComponent <RectTransform>();

        rectTransform.SetParent(parent.transform);
        rectTransform.sizeDelta  = new Vector2(0, 0);       // width 0x0
        rectTransform.localScale = new Vector3(1, 1, 1);    // scale 1, 1, 1
        child.SetPosition(0, 0);                            // position 0, 0

        if (!string.IsNullOrEmpty(name))
        {
            child.name = name;
        }
        return(child);
    }
Пример #36
0
        /// <summary>
        ///		Executes when a collison occurs with another GameObject
        /// </summary>
        /// <param name="collisonName"></param>
        /// <param name="other"></param>
        /// <returns>
        ///		<c>true</c> if the object is to be deleted
        ///	</returns>
        public override bool OnCollide(CollisionPairEvaluator.Name collisonName, GameObject other)
        {
            bool willBeDeleted = false;

            // PlayerLaser vs AlienLaser
            if (collisonName == CollisionPairEvaluator.Name.PlayerLaser_vs_AlienLaser)
            {
                willBeDeleted = true;
            }
            // Player vs AlienLaser
            else if (collisonName == CollisionPairEvaluator.Name.Player_vs_AlienLaser)
            {
                willBeDeleted = true;

                // Create small explosion
                DeadPlayerLaser smallExplosion = new DeadPlayerLaser(this.X, this.Y);
                smallExplosion.SetColor(Colors.Green);

                // Move up. This is important!
                // Removing this line will make the Aliens rain laser everywhere!
                GameObject parent = this.Parent as GameObject;
                parent.SetPosition(parent.X, parent.Y + this.Height);
            }
            // AlienLaser vs Shields
            else if (collisonName == CollisionPairEvaluator.Name.AlienLaser_vs_Shield)
            {
                willBeDeleted = true;

                // Create small explosion
                DeadPlayerLaser smallExplosion = new DeadPlayerLaser(this.X, this.Y);
                smallExplosion.SetColor(Colors.Green);
            }
            // AlienLaser vs WallBottom
            else if (collisonName == CollisionPairEvaluator.Name.AlienLaser_vs_WallBottom)
            {
                willBeDeleted = true;

                // Create small explosion
                DeadPlayerLaser smallExplosion = new DeadPlayerLaser(this.X, this.Y);
                smallExplosion.SetColor(Colors.Green);
            }


            return(willBeDeleted);
        }
Пример #37
0
	public void MakeMeLaser(Color color)
	{
		/*
		foreach(GameObject go in GameObject.FindObjectsOfType(typeof(GameObject)))
		{
			if(go.name == "lineUP")
			{
				GameObject.Destroy (go);
			}
		}
		// Set LineRenderer InitializationGameObject yourName = new GameObject();
		LineRenderer lineRenderer = new GameObject("lineUP").AddComponent<LineRenderer>();
		lineRenderer.sharedMaterial = new Material(Shader.Find("Particles/Additive"));
		lineRenderer.SetColors(Color.red, Color.red);
		lineRenderer.SetWidth(1f, 1f);
		lineRenderer.SetVertexCount(2);
		
		// We need no Shadows
		lineRenderer.castShadows = false;
		lineRenderer.receiveShadows = false;
		Debug.Log ("Raw posX: " + posX + "Raw posX: " + posY);

		float worldX = posX * 4;
		float worldZ = posY * 4;

		Vector3 pos = new Vector3(worldX + 2, 0, worldZ + 2);
		lineRenderer.SetPosition(0, pos);

		pos = new Vector3(worldX + 2, 800, worldZ + 2);
		lineRenderer.SetPosition(1, pos);
		*/
		// Make 
		//GameController.instance.treeGroupController.AddTreeGroup(posX, posY);

		RaycastHit hit;

		// Set LineRenderer InitializationGameObject yourName = new GameObject();
		LineRenderer lineRenderer = new GameObject("lineUP").AddComponent<LineRenderer>();
		lineRenderer.sharedMaterial = new Material(Shader.Find("Particles/Additive"));
		lineRenderer.SetColors(color, color);
		lineRenderer.SetWidth(0.2f, 0.2f);
		lineRenderer.SetVertexCount(5);
		
		// We need no Shadows
		lineRenderer.castShadows = false;
		lineRenderer.receiveShadows = false;
		
		float worldX = posX * 4;
		float worldZ = posY * 4;
		Vector3 pos;
		Ray ray = new Ray(new Vector3(worldX, 10, worldZ), Vector3.up);
		if (Physics.Raycast (ray, out hit)) 
		{
			pos = new Vector3(worldX, hit.point.y + 1, worldZ);
			lineRenderer.SetPosition(0, pos);
		}


		ray = new Ray(new Vector3(worldX + 4, 10, worldZ), Vector3.up);
		if (Physics.Raycast (ray, out hit)) 
		{
			pos = new Vector3(worldX + 4, hit.point.y + 1, worldZ);
			lineRenderer.SetPosition(1, pos);
		}

		ray = new Ray(new Vector3(worldX + 4, 10, worldZ + 4), Vector3.up);
		if (Physics.Raycast (ray, out hit)) 
		{
			pos = new Vector3(worldX + 4, hit.point.y + 1, worldZ + 4);
			lineRenderer.SetPosition(2, pos);
		}

		ray = new Ray(new Vector3(worldX, 10, worldZ + 4), Vector3.up);
		if (Physics.Raycast (ray, out hit)) 
		{
			pos = new Vector3(worldX, hit.point.y + 1, worldZ + 4);
			lineRenderer.SetPosition(3, pos);
		}

		ray = new Ray(new Vector3(worldX, 10, worldZ), Vector3.up);
		if (Physics.Raycast (ray, out hit)) 
		{
			pos = new Vector3(worldX, hit.point.y + 1, worldZ);
			lineRenderer.SetPosition(4, pos);
		}
	

		lineRenderer.gameObject.AddComponent<SelectionLine>();
	}
Пример #38
0
 private void makeLineGraph(Vector3 begin, Vector3 end)
 {
     //makePoint(begin);
    // makePoint(end);
     LineRenderer line = new GameObject().AddComponent<LineRenderer>();
     line.transform.parent = this.transform.parent;
     line.SetWidth(0.05F, 0.05F);
     line.SetColors(Color.green, Color.green);
     line.SetPosition(0, begin);
     line.SetPosition(1, end);
     line.SetVertexCount(2);
     line.material = new Material(Shader.Find("Particles/Additive"));
 }
        public static void RemoveMoveInteractions(GameObject gameObject, bool resetLocation)
        {
            if (MovedObjects.ContainsKey(gameObject))
            {
                if (resetLocation)
                {
                    LocationVectors vectors;
                    if (MovedObjects.TryGetValue(gameObject, out vectors))
                    {
                        gameObject.SetForward(vectors.ForwardVector);
                        gameObject.SetPosition(vectors.Position);
                    }
                }
                MovedObjects.Remove(gameObject);
            }
            gameObject.RemoveInteractionByType(StopMovingMe.Singleton);

            gameObject.RemoveInteractionByType(TurnLeft.Singleton);
            gameObject.RemoveInteractionByType(TurnAtAngle.Singleton);
            gameObject.RemoveInteractionByType(TurnRight.Singleton);
            gameObject.RemoveInteractionByType(TurnAround.Singleton);
            gameObject.RemoveInteractionByType(TiltFaceUp.Singleton);
            gameObject.RemoveInteractionByType(TiltBack.Singleton);
            gameObject.RemoveInteractionByType(TiltForward.Singleton);
            gameObject.RemoveInteractionByType(TiltFaceDown.Singleton);
            gameObject.RemoveInteractionByType(TiltUserDefined.Singleton);

            gameObject.RemoveInteractionByType(MoveUp.Singleton);
            gameObject.RemoveInteractionByType(MoveUpUserDefined.Singleton);
            gameObject.RemoveInteractionByType(MoveDown.Singleton);
            gameObject.RemoveInteractionByType(MoveDownUserDefined.Singleton);
            gameObject.RemoveInteractionByType(MoveBack.Singleton);
            gameObject.RemoveInteractionByType(MoveBackUserDefined.Singleton);
            gameObject.RemoveInteractionByType(MoveForward.Singleton);
            gameObject.RemoveInteractionByType(MoveForwardUserDefined.Singleton);

            gameObject.RemoveInteractionByType(MoveRight.Singleton);
            gameObject.RemoveInteractionByType(MoveRightUserDefined.Singleton);
            gameObject.RemoveInteractionByType(MoveLeft.Singleton);
            gameObject.RemoveInteractionByType(MoveLeftUserDefined.Singleton);
        }
Пример #40
0
 public static void ParentToSlot(GameObject obj, Slot slot, GameObject parent)
 {
     if (obj != null && parent != null)
     {
         obj.SetPosition(parent.GetPositionOfSlot(slot));
         obj.SetForward(parent.GetForwardOfSlot(slot));                
         obj.ParentToSlot(parent, slot);                
     }
 }
 protected void drawLine(Vector3 start, Vector3 end, Color color)
 {
     LineRenderer line = new GameObject("Line ").AddComponent<LineRenderer>();
     line.SetWidth(0.025F, 0.025F);
     line.SetColors(color, color);
     line.SetVertexCount(2);
     line.SetPosition(0, start);
     line.SetPosition(1, end);
     line.material.shader = (Shader.Find("Unlit/Color"));
     line.material.color = color;
     lines.Add(line.gameObject);
 }