示例#1
0
 // Update is called once per frame
 void Update()
 {
     /*
      * // (Debug)
      * if (Input.GetKeyDown(KeyCode.Z)) {
      *  Attack();
      * }
      *
      * if (Input.GetKeyUp(KeyCode.Z)) {
      *  TurtleAni.SetBool("Attack", false);
      * }
      *
      * if (Input.GetKeyDown(KeyCode.X))
      * {
      *  FuryAttack();
      * }
      *
      * if (Input.GetKeyUp(KeyCode.X))
      * {
      *  TurtleAni.SetBool("Fury", false);
      * }
      */
     if (Input.GetKeyDown(KeyCode.Space))
     {
         HP -= 5;
         TurtleAni.SetInteger("HP", HP);
         if (HP == 0)
         {
             state = TurtleState.Dead;
             StartCoroutine("DelayDying");
         }
         StartCoroutine("DelayStunning");
     }
 }
示例#2
0
 public TurtleState(TurtleState t)
 {
     pos      = new Vector3(t.pos.x, t.pos.y, t.pos.z);
     stepSize = t.stepSize;
     width    = t.width;
     rot      = Quaternion.Euler(t.rot.eulerAngles);
 }
示例#3
0
    private void FuryAttack()
    {
        state = TurtleState.Attack;
        TurtleAni.SetBool("Fury", true);

        StartCoroutine(DelayAttack(3.0f));
    }
 public void CheckForRespawn(float TimeElapsed)
 {
     if (prevstate == TurtleState.stand && state == TurtleState.stand && collisionYbot)
     {
         timeToRespawn += TimeElapsed;
         if (timeToRespawn > 2 && timeToRespawn <= 4)
         {
             BeginRespawn = true;
         }
         else if (timeToRespawn > 4)
         {
             state = TurtleState.walk;
             if (rectangle.height == 32)
             {
                 this.rectangle = new Rectangle(rectangle.X, rectangle.Y - 32, 32, 64);
             }
             timeToRespawn = 0;
             BeginRespawn  = false;
         }
     }
     else
     {
         timeToRespawn = 0;
         BeginRespawn  = false;
     }
 }
示例#5
0
        static Turtle SetupTurtle()
        {
            var table       = new Table();
            var turtleState = new TurtleState();

            return(new Turtle(turtleState, table));
        }
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString)
        {
            var paramIndex = sourceString.parameters[indexInString];

            if (paramIndex.length == 0)
            {
                state.transformation *= Matrix4x4.Scale(defaultScaleFactor * nonUniformScale);
            }
            else
            if (paramIndex.length == 1)
            {
                state.transformation *= Matrix4x4.Scale(sourceString.parameters[paramIndex, 0] * nonUniformScale);
            }
            else
            if (paramIndex.length == 3)
            {
                state.transformation *= Matrix4x4.Scale(
                    new Vector3(
                        sourceString.parameters[paramIndex, 0],
                        sourceString.parameters[paramIndex, 1],
                        sourceString.parameters[paramIndex, 2]
                        ));
            }
            else
            {
                Debug.LogError($"Invalid scale parameter length: {paramIndex.length}");
            }
        }
示例#7
0
        public void SequenceOfCommands_All_Valid()
        {
            var table       = new Table();
            var turtleState = new TurtleState();
            var turtle      = new Turtle(turtleState, table);

            string reportMessage = "";

            Action <string>     report              = (msg) => reportMessage = msg;
            Action              clearCommandLine    = () => { };
            Func <string, bool> isValidPlaceCommand = (cmd) => { return(true); };

            var commandSequence = new List <string>()
            {
                "PLACE 0,0,NORTH",
                "MOVE",
                "MOVE",
                "MOVE",
                "RIGHT",
                "MOVE",
                "LEFT",
                "MOVE",
                "LEFT",
                "REPORT"
            };

            foreach (var command in commandSequence)
            {
                turtle.ProcessCommand(command, report, clearCommandLine, isValidPlaceCommand);
            }

            reportMessage.Should().Be("1 4 WEST");
        }
示例#8
0
        public void SequenceOfCommands_Valid_Place_Coordinates_MoveOutSideTable_SOUTH()
        {
            var table       = new Table();
            var turtleState = new TurtleState();
            var turtle      = new Turtle(turtleState, table);

            string reportMessage = "";

            Action <string>     report              = (msg) => reportMessage = msg;
            Action              clearCommandLine    = () => { };
            Func <string, bool> isValidPlaceCommand = (cmd) => { return(true); };

            var commandSequence = new List <string>()
            {
                "PLACE 0,0,SOUTH",
                "MOVE",
                "MOVE",
                "MOVE",
                "MOVE",
                "MOVE",
                "MOVE",
                "REPORT"
            };

            foreach (var command in commandSequence)
            {
                turtle.ProcessCommand(command, report, clearCommandLine, isValidPlaceCommand);
            }

            reportMessage.Should().Be("0 0 SOUTH");
        }
        private void GoForward()
        {
            float newX = state.Point.X + trailLen * (float)Math.Cos(state.Angle);
            float newY = state.Point.Y + trailLen * (float)Math.Sin(state.Angle);

            state = new TurtleState(new PointF(newX, newY), state.Angle);
        }
 public Turtle()
 {
     pen      = new Pen(PEN_COLOR, MIN_PEN_WIDTH);
     trailLen = MIN_TRAIL_LEN;
     state    = new TurtleState(new PointF(START_X, START_Y), NORTH);
     states   = new Stack <TurtleState>();
 }
示例#11
0
    IEnumerator DelayStunning()
    {
        state = TurtleState.Idle;
        yield return(new WaitForSeconds(1.5f));

        state = TurtleState.Wander;
    }
示例#12
0
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString)
        {
            var   paramIndex = sourceString.parameters[indexInString];
            float bendFactor = defaultBendFactor;

            if (paramIndex.length == 1)
            {
                bendFactor = sourceString.parameters[paramIndex, 0];
            }
            var localBendDirection = state.transformation.inverse.MultiplyVector(defaultBendDirection);
            var adjustment         = (bendFactor) * (Vector3.Cross(localBendDirection, Vector3.right));

            state.transformation *= Matrix4x4.Rotate(
                Quaternion.Slerp(
                    Quaternion.identity,
                    Quaternion.FromToRotation(
                        Vector3.right,
                        localBendDirection),
                    adjustment.magnitude
                    )
                );
        }
示例#13
0
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString,
            TurtleVolumetricHandles volumetricHandles)
        {
            var paramIndex = sourceString.parameters[indexInString];

            if (paramIndex.length != 1)
            {
                return;
            }
            var pointInLocalSpace = state.transformation.MultiplyPoint(Vector3.zero);
            var voxelIndex        = volumetricHandles.universalWriter.GetVoxelIndexFromLocalSpace(pointInLocalSpace);

            if (!voxelIndex.IsValid)
            {
                return;
            }

            var amountInSymbol = sourceString.parameters[paramIndex, 0];

            if (diffusionDirection == OrganDiffusionDirection.PUMP_OUT)
            {
                volumetricHandles.universalWriter.AppendAmountChangeToOtherLayer(voxelIndex, amountInSymbol, resourceLayerId);
                return;
            }
            var amountInVoxel      = volumetricHandles.volumetricData[voxelIndex, resourceLayerId];
            var diffusionToLSystem = (amountInVoxel - amountInSymbol) * diffusionConstant;

            switch (diffusionDirection)
            {
            case OrganDiffusionDirection.DIFFUSE_IN_ONLY:
                diffusionToLSystem = math.max(diffusionToLSystem, 0);
                break;

            case OrganDiffusionDirection.DIFFUSE_OUT_ONLY:
                diffusionToLSystem = math.min(diffusionToLSystem, 0);
                break;

            default:
                break;
            }

            if (diffusionCap > 0)
            {
                var maxAllowableDiffuseIn = math.max(diffusionCap - amountInSymbol, 0);
                diffusionToLSystem = math.min(diffusionToLSystem, maxAllowableDiffuseIn);
                var maxAllowableDiffuseOut = math.max(diffusionCap - amountInVoxel, 0);
                diffusionToLSystem = -math.min(-diffusionToLSystem, maxAllowableDiffuseOut);
            }
            if (diffusionToLSystem == 0)
            {
                return;
            }

            sourceString.parameters[paramIndex, 0] = amountInSymbol + diffusionToLSystem;
            volumetricHandles.universalWriter.AppendAmountChangeToOtherLayer(voxelIndex, -diffusionToLSystem, resourceLayerId);
        }
示例#14
0
 internal Turtle(Point startPosition, Direction startDirection)
 {
     this.StartPosition    = startPosition;
     this.CurrentPosition  = startPosition;
     this.StartDirection   = startDirection;
     this.CurrentDirection = startDirection;
     this.Status           = TurtleState.IsInDanger;
 }
示例#15
0
    private void Attack()
    {
        state = TurtleState.Attack;
        TurtleAni.SetBool("Attack", true);
        print(TurtleAni.GetCurrentAnimatorStateInfo(0).normalizedTime);

        StartCoroutine(DelayAttack(1.5f));
    }
        private bool Place(TurtleState currentState)
        {
            if (IsInsideRange(currentState.XPos, currentState.YPos))
            {
                this.State = currentState;
                return(true);
            }

            return(false);
        }
示例#17
0
        public void TurtleIsInDanger_EvaluateMultipleCommands_ReturnsCorrectState(
            Board board,
            IEnumerable <ITurtleCommand> commands,
            TurtleState expectedState)
        {
            var sut = MakeBoardEvaluator(board);

            var actual = sut.Evaluate(commands);

            Assert.Equal(expectedState, actual);
        }
示例#18
0
 private void Awake()
 {
     if (Instance == null)
     {
         Instance = this;
     }
     else
     {
         throw new Exception("There can only be one TurtleStats in a scene!");
     }
     turtleTransition = GetComponent <TurtleTransition>();
 }
示例#19
0
    //create the physical representation
    void axiomInterpreter(string axi)
    {
        Stopwatch timer = new Stopwatch();

        timer.Start();

        Vector3 curLoc = new Vector3(0, 0, 0);

        for (int i = 0; i < axi.Length; i++)
        {
            if (axi.ToCharArray()[i].ToString().Equals("-"))
            {
                int rand = Random.Range(-this.stochasticAngle, this.stochasticAngle);
                this.curAngle -= this.angle + rand;
            }
            else if (axi.ToCharArray()[i].ToString().Equals("+"))
            {
                int rand = Random.Range(-this.stochasticAngle, this.stochasticAngle);
                this.curAngle += this.angle + rand;
            }
            else if (axi.ToCharArray()[i].ToString().Equals("("))
            {
                this.turtleStack.Push(new TurtleState(this.curAngle, curLoc));
            }
            else if (axi.ToCharArray()[i].ToString().Equals(")"))
            {
                TurtleState temp = this.turtleStack.Pop();
                this.curAngle = temp.getAngle();
                curLoc        = temp.getPosition();
            }
            else if (axi.ToCharArray()[i].ToString().Equals("X"))
            {
            }
            else
            {
                for (int j = 0; j < 5; j++)
                {
                    GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
                    sphere.transform.localScale = new Vector3(1f, 1f, 1f);
                    sphere.transform.Rotate(0, this.curAngle, 0);
                    sphere.transform.position = curLoc;
                    Color matColor = colorGen(curLoc.x, curLoc.y, this.curAngle);
                    sphere.renderer.material.color = matColor;
                    Transform temp = sphere.transform;
                    temp.Translate(0, 0, 1);
                    curLoc = temp.position;                     //TODO: don't reallocate memory every time
                }
            }
            timer.Stop();
            UnityEngine.Debug.Log(timer.ElapsedTicks + ": time taken :" + timer.ElapsedMilliseconds);
        }
    }
示例#20
0
 // Use this for initialization
 void Start()
 {
     state          = TurtleState.Wander;
     TurtleAni      = this.GetComponent <Animator>();
     sprd           = this.GetComponent <SpriteRenderer>();
     TimeInterval   = Random.Range(3.0f, 5.0f);
     AttackInterval = 5.0f;
     catchTime      = Time.time;
     getTime        = Time.time;
     fury           = (int)Random.Range(3, 5);
     TurtleAni.SetInteger("HP", HP);
     audio = gameObject.GetComponent <AudioSource>();
 }
示例#21
0
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString)
        {
            var   paramIndex = sourceString.parameters[indexInString];
            float theta      = defaultTheta;

            if (paramIndex.length >= 1)
            {
                theta = sourceString.parameters[paramIndex, 0];
            }
            state.transformation *= Matrix4x4.Rotate(Quaternion.Euler(theta * unitEulerRotation));
        }
示例#22
0
        public void Valid_First_Command_Return_True()
        {
            var table       = new Table();
            var turtleState = new TurtleState();
            var turtle      = new Turtle(turtleState, table);

            string              input               = "PLACE 0,0,NORTH";
            Action <string>     message             = (msg) => { };
            Action              clearCommandLine    = () => { };
            Func <string, bool> isValidPlaceCommand = (cmd) => { return(true); };

            var result = turtle.ProcessCommand(input, message, clearCommandLine, isValidPlaceCommand);

            result.Should().Be(true);
        }
示例#23
0
    public void addLeafVert(TurtleState turtleState)
    {
        Vector3 center   = turtleState.baseCenter;
        Vector3 rotation = turtleState.angle;

        float xAngle = rotation.x;
        float yAngle = rotation.y;

        Vector3 newCenter = new Vector3(
            center.x + length * Mathf.Cos(xAngle) * Mathf.Cos(yAngle),
            center.y + length * Mathf.Sin(xAngle),
            center.z + length * Mathf.Cos(xAngle) * Mathf.Sin(yAngle));

        newLeafVs.Add(newCenter);
        turtleState.baseCenter = newCenter;
    }
示例#24
0
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString,
            EntityCommandBuffer spawningCommandBuffer,
            Matrix4x4 localToWorldTransform)
        {
            var paramIndex = sourceString.parameters[indexInString];

            var spawned        = spawningCommandBuffer.Instantiate(instantiableEntity);
            var newbuffer      = spawningCommandBuffer.SetBuffer <TurtleSpawnedParameters>(spawned);
            var parameterSlice = sourceString.parameters.data.Slice(paramIndex.index, paramIndex.length);

            newbuffer.CopyFrom(parameterSlice.SliceConvert <TurtleSpawnedParameters>());

            var totalLocalToWorld = localToWorldTransform * state.transformation * prefabTransform;

            var     rot = totalLocalToWorld.rotation;
            Vector3 pos = totalLocalToWorld.GetColumn(3);

            // Extract new local scale
            Vector3 scale = new Vector3(
                totalLocalToWorld.GetColumn(0).magnitude,
                totalLocalToWorld.GetColumn(1).magnitude,
                totalLocalToWorld.GetColumn(2).magnitude
                );

            spawningCommandBuffer.SetComponent(spawned, new Rotation
            {
                Value = rot
            });
            spawningCommandBuffer.SetComponent(spawned, new Translation
            {
                Value = pos
            });

            // scale is done a bit differently for everything. if scale changes are needed, read from the TurtleSpawnedParameters
            //spawningCommandBuffer.SetComponent(instantiableEntity, new NonUniformScale
            //{
            //    Value = scale
            //});

            //spawningCommandBuffer.SetComponent(instantiableEntity, new LocalToWorld
            //{
            //    Value = localToWorldTransform * state.transformation
            //});
        }
示例#25
0
        public static string GetTurtleString(TurtleState turtleState)
        {
            switch (turtleState)
            {
            case TurtleState.good:
                return("good");

            case TurtleState.bad:
                return("bad");

            case TurtleState.worse:
                return("worse");

            default:
                return("neutral");
            }
        }
示例#26
0
        /// <summary>
        ///     Execute REPORT command
        /// </summary>
        /// <param name="turtle">turtle instance</param>
        /// <param name="arguments">NOT REQUIRED</param>
        /// <param name="message">message after command execution result</param>
        /// <returns>command execution result</returns>
        public bool DoExecution(ITurtle turtle, string[] arguments, out string message)
        {
            bool isSuccess;

            if (turtle != null && turtle.Report() != null)
            {
                TurtleState currentState = turtle.Report();
                isSuccess = true;
                message   = string.Format("{0}, {1}, {2}", currentState.X, currentState.Y, currentState.FacingDirection.ToString().ToUpper());
            }
            else
            {
                isSuccess = false;
                message   = MessageConstants.InvalidStateMsg;
            }

            return(isSuccess);
        }
示例#27
0
        /* Update States */

        /* Turtle */

        private void UpdateTimedData(object sender, ElapsedEventArgs e)
        {
            TimeSpan timeElapsed = e.SignalTime - timeKeeper.StartTime;

            TurtleState newTurtleState = turtle.CurrentTurtleState;

            if (turtle.TurtleName != turtleNameLabel.Text)
            {
                turtleNameLabel.Text = turtle.TurtleName.ToString();
            }


            if (timeElapsed.TotalSeconds < 20)
            {
                newTurtleState = TurtleState.good;
            }
            else if (timeElapsed.TotalSeconds < 40)
            {
                newTurtleState = TurtleState.bad;
            }
            else if (timeElapsed.TotalSeconds >= 120)
            {
                newTurtleState = TurtleState.worse;
            }

            /* Display bag and jellyfish */

            if (timeElapsed.TotalSeconds >= 10)
            {
                Device.BeginInvokeOnMainThread(() =>
                {
                    bag.FadeTo(1, 500, Easing.Linear);
                    jellyfish.FadeTo(1, 500, Easing.Linear);
                });
            }

            /* Update state */

            if (newTurtleState != turtle.CurrentTurtleState)
            {
                turtle.CurrentTurtleState = newTurtleState;
                updateUI();
            }
        }
示例#28
0
    IEnumerator  DelayAttack(float force)
    {
        yield return(new WaitForSeconds(0.5f));

        if (PhotonNetwork.isMasterClient)
        {
            PhotonNetwork.InstantiateSceneObject("Roll", this.transform.position + Vector3.left * ((flip == false)? 1:-1) * force, this.transform.rotation, 0, null);
        }

        state = TurtleState.Wander;
        if (force == 3.0f)
        {
            TurtleAni.SetBool("Fury", false);
        }
        else
        {
            TurtleAni.SetBool("Attack", false);
        }
    }
示例#29
0
        private static string DescriptionForState(TurtleState state)
        {
            switch (state)
            {
            case TurtleState.InDanger:
                return("Still in danger!");

            case TurtleState.HitMine:
                return("Mine hit!");

            case TurtleState.FoundExit:
                return("Success!");

            case TurtleState.OutOfBounds:
                return("Out of bounds!");
            }

            return("Unknown state");
        }
        public void Operate(
            ref TurtleState state,
            int indexInString,
            SymbolString <float> sourceString)
        {
            var paramIndex = sourceString.parameters[indexInString];

            if (paramIndex.length == 0)
            {
                state.thickness *= defaultThicknessScale;
            }
            else
            if (paramIndex.length == 1)
            {
                state.thickness *= sourceString.parameters[paramIndex, 0];
            }
            else
            {
                Debug.LogError($"Invalid scale parameter length: {paramIndex.length}");
            }
        }
示例#31
0
 public TurtleState(TurtleState ts)
     : this(new Point2D(ts.pos), new Point2D(ts.dir), new Rotation(ts.rot))
 {
 }
 public Turtle(float w)
 {
     turtleState = new TurtleState(w, Matrix4x4.identity);
     tss = new Stack<TurtleState>();
 }
 // Restore a previous state
 public void Pop()
 {
     if (tss.Count==0){
         Debug.LogError("Invalid pop. Stack is empty (more pop than push)");
     }
     turtleState = tss.Pop();
 }
示例#34
0
        public Skeleton(String Filename, StreamWriter logSW)
        {
            //Read in Skeleton
            StreamReader input = new StreamReader(Filename);
            TurtleState current = new TurtleState(new Point2D(0, 0), new Point2D(1, 0), new Rotation());
            List<TurtleState> turtleStack = new List<TurtleState>();
            Dictionary<String, Rotation> sphereTable = new Dictionary<string,Rotation>();

            while (!input.EndOfStream)
            {
                String LineIn = input.ReadLine();
                char[] charSeparators = { ' ', ',', '=', '\t' };
                String[] tokens = LineIn.Split( charSeparators, StringSplitOptions.RemoveEmptyEntries );

                if( tokens.Length == 0 || tokens[0].StartsWith("#") )
                {
                    continue;
                } /* if */

                //FIRST TOKEN = command
                String command = (tokens[0]).ToLower();

                //SECOND TOKEN = distance (or label)
                double fDistance = 0.0;
                if (tokens.Length >= 2)
                {
                    try
                    {
                        fDistance = double.Parse(tokens[1]) * DMS.HALFTAU;
                    }
                    catch (System.FormatException)
                    {
                        // if second token not a number, it could be a label.
                        if (command == "s" || command == "save")
                        {
                            // save the label and move on.
                            sphereTable[tokens[1]] = current.rot;
                            continue;
                        }
                        else if (sphereTable.ContainsKey(tokens[1]))
                        {
                            Rotation newRot = sphereTable[tokens[1]];
                            Point3D A = current.rot.Rotate(-Point3D.XAxis);
                            Point3D B = current.rot.Rotate(Point3D.ZAxis);
                            Point3D C = newRot.Rotate(Point3D.ZAxis);

                            // add a rotation from AB to BC
                            double turn = Math.PI - Point3D.DihedralAngle(A, B, C);
                            if (Point3D.Dot(B, Point3D.Cross(A - B, B - C)) < 0)
                            {
                                turn *= -1.0;
                            }
                            current.dir.Theta += turn;
                            current.rot *= new Rotation(Math.Cos(turn / 2.0), 0, 0, Math.Sin(turn / 2.0));

                            if (command == "r" || command == "rotate")
                            {
                                continue;
                            }
                            else if (command == "l" || command == "line" || command == "lineto" ||
                                command == "m" || command == "move" || command == "moveto")
                            {
                                // move or line from B to C
                                fDistance = Point3D.Angle(B, Point3D.Origin, C) - 0.01;
                            }
                        }
                    }
                }

                //THIRD TOKEN = strength
                double fStrength = 1.0;
                if (tokens.Length >= 3)
                {
                    try
                    {
                        fStrength = 1.0 / double.Parse(tokens[2]);
                    }
                    catch (System.FormatException)
                    {
                        continue;
                    }
                }

                if( command == "l" || command == "line" || command == "lineto" )
                {
                    if (fDistance == 0.0)
                        m_Segments.Add(new Segment(current.rot, current.pos, current.pos + current.dir, fStrength, true));
                    else if (fDistance > 0.0)
                        m_Segments.Add(new Segment(current.rot, current.pos, current.pos + current.dir * fDistance, fStrength));
                    else
                        m_Segments.Add(new Segment(current.rot * new Rotation(0, 0, 0, 1), current.pos, current.pos + current.dir * fDistance, fStrength));

                    current.pos += current.dir * fDistance;
                    current.rot *= new Rotation(Math.Cos(fDistance / 2.0), 0, Math.Sin(fDistance / 2.0), 0);
                }
                else if( command == "m" || command == "move" || command == "moveto" )
                {
                    //move
                    current.pos += current.dir * fDistance;
                    current.rot *= new Rotation(Math.Cos(fDistance / 2.0), 0, Math.Sin(fDistance / 2.0), 0);
                }
                else if( command == "o" || command == "moveinplane" )
                {
                    //move in plane *O*nly
                    current.pos += current.dir * fDistance;
                }
                else if( command == "r" || command == "rotate" )
                {
                    //rotate (clockwise)
                    current.dir.Theta += fDistance;
                    current.rot *= new Rotation( Math.Cos(fDistance / 2.0), 0, 0, Math.Sin(fDistance / 2.0) );
                }
                else if( command == "p" && fDistance > 0 || command == "push" || command == "{")
                {
                    turtleStack.Add(new TurtleState(current));
                }
                else if (command == "p" || command == "pop" || command == "}")
                {
                    current = turtleStack.Last<TurtleState>();
                    turtleStack.Remove(current);
                }
                else if (command == "b" || command == "bleedout")
                {
                    m_bleedout = fDistance;
                }
            } /* while */

            input.Close();
        }