Esempio n. 1
0
    /**
     * Loops through all the things the user could possibly be trying to click
     * and if the user is clicking an argument of this expression piece rather
     * than this expression piece itself, "forwards the click" i.e. calls the
     * OnClick() method of the argument.
     */
    void IPointerClickHandler.OnPointerClick(PointerEventData eventData)
    {
        List <RaycastResult> results = new List <RaycastResult>();

        EventSystem.current.RaycastAll(eventData, results);

        ExpressionPiece argumentClicked = null;

        foreach (RaycastResult r in results)
        {
            if (r.gameObject.GetComponent <ExpressionPiece>() != null && r.gameObject.GetComponent <ExpressionPiece>().id.Equals("_"))
            {
                argumentClicked = r.gameObject.GetComponent <ExpressionPiece>();
                break;
            }
        }

        //if user wasn't clicking any empty arguments, call OnClick() for this ExpressionPiece;
        //otherwise, call OnClick() for the clicked empty arg
        if (argumentClicked == null)
        {
            if (this.gameController.selectedExpression != null && !this.gameController.selectedExpression.Equals(this))
            {
                this.gameController.failure.Play();
            }
            this.OnClick();
        }
        else
        {
            argumentClicked.OnClick();
        }
    }
Esempio n. 2
0
    public ExpressionPiece DeepCopy(bool isFirstCall)
    {
        GameObject exprPiece         = Resources.Load("Piece") as GameObject;
        GameObject exprPieceInstance = Instantiate(exprPiece, new Vector2(0, 0), Quaternion.identity) as GameObject;

        exprPieceInstance.transform.position = this.transform.position;
        ExpressionPiece exprPieceScript = exprPieceInstance.GetComponent <ExpressionPiece>();

        exprPieceScript.gameController = this.gameController;
        exprPieceScript.id             = this.expression.ToString();
        exprPieceScript.expression     = this.expression;
        exprPieceScript.arguments      = new ExpressionPiece[this.arguments.Length];
        exprPieceScript.heightInUnits  = this.heightInUnits;
        exprPieceScript.widthInUnits   = this.widthInUnits;
        exprPieceScript.index          = this.index;

        for (int i = 0; i < this.arguments.Length; i++)
        {
            if (this.arguments[i] != null)
            {
                exprPieceScript.arguments[i] = this.arguments[i].DeepCopy(false);
                exprPieceScript.arguments[i].SetParentExpressionPiece(exprPieceScript);
            }
        }
        return(exprPieceScript);
    }
Esempio n. 3
0
    /**
     * Called after an ExpressionPiece is created for the first time (all
     * arguments are empty) to set up the piece. I.e. called when an
     * ExpressionPiece is created by a Spawner, Controller or something that isn't OnDrop().
     */
    public void Initialize(Expression expr)
    {
        gameController  = GameObject.Find("GameController").GetComponent <GameController>();
        this.expression = expr;
        this.arguments  = new ExpressionPiece[expr.GetNumArgs()];
        this.gameObject.transform.position = GetStartingPosition();
        GameObject tabletop = GameObject.Find("Workspace");

        this.gameObject.transform.SetParent(this.transform.parent.transform);

        if (arguments.Length > 0)
        {
            this.heightInUnits = 2;
            this.widthInUnits  = expr.GetNumArgs() + 1;
        }

        int   counter          = 0;
        int   currentX         = 1;
        float calculatedWidth  = PIXELS_PER_UNIT * this.widthInUnits;
        float calculatedHeight = PIXELS_PER_UNIT * this.heightInUnits;

        // build empty arguments
        for (int i = 0; i < arguments.Length; i++)
        {
            // Expression argExpression = expr.GetArg(i);
            if (DRAW_OPEN_ARGUMENT_TYPE)
            {
                GameObject argumentPiece = Resources.Load("Piece") as GameObject;
                argumentPiece.name = "Argument";
                GameObject argumentPieceInstance =
                    Instantiate(argumentPiece, this.transform.position, Quaternion.identity) as GameObject;
                ExpressionPiece argumentPieceScript = argumentPieceInstance.GetComponent <ExpressionPiece>();
                argumentPieceScript.gameController = gameController;
                argumentPieceScript.expression     = new Word(expr.GetInputType(counter), "_");
                argumentPieceScript.arguments      = new ExpressionPiece[0];

                //NOTE: arg positions are set relative to the center of their container expressions, by the center of the arg
                float overallPieceHeight   = calculatedHeight;
                float overallPieceWidth    = calculatedWidth;
                float overallPieceTopLeftX = this.transform.position.x - calculatedWidth / 2.0f;
                float overallPieceTopLeftY = this.transform.position.y + calculatedHeight / 2.0f;

                float argTopLeftX = overallPieceTopLeftX + PIXELS_PER_UNIT * currentX;
                float argTopLeftY = overallPieceTopLeftY - 1 * PIXELS_PER_UNIT;
                float argCenterX  = argTopLeftX + (PIXELS_PER_UNIT * .5f) - BUFFER_IN_PIXELS; //.5f b/c center of arg w/ width & height 1
                float argCenterY  = argTopLeftY - (PIXELS_PER_UNIT * .5f) + BUFFER_IN_PIXELS;

                argumentPieceInstance.transform.SetParent(this.gameObject.transform);
                argumentPieceInstance.transform.position = new Vector3(argCenterX, argCenterY);

                argumentPieceScript.id    = "_";
                argumentPieceScript.index = counter;
                argumentPieceScript.SetParentExpressionPiece(this);
                this.arguments[i] = argumentPieceScript;
                counter++;
            }
            currentX++;
        }
    }
    /**
     * Creates an new ExpressionPiece based on this ExpressionPieceSpawner
     */
    public ExpressionPiece MakeNewExpressionPiece()
    {
        GameObject workspace         = GameObject.Find("Workspace");
        GameObject exprPiece         = Resources.Load("Piece") as GameObject;
        GameObject exprPieceInstance = Instantiate(exprPiece, new Vector2(0, 0), Quaternion.identity) as GameObject;

        exprPieceInstance.transform.SetParent(workspace.transform);
        ExpressionPiece exprPieceScript = exprPieceInstance.GetComponent <ExpressionPiece>();

        exprPieceScript.Initialize(expression);
        exprPieceScript.SetVisual(exprPieceScript.GenerateVisual());

        return(exprPieceInstance.GetComponent <ExpressionPiece>());
    }
Esempio n. 5
0
 /**
  * if the game is in Speaking Mode (kept track of by a bool in GameController,
  * and this NPC is clicked, say the expression to the NPC.
  */
 private void OnMouseDown()
 {
     if (!EventSystem.current.IsPointerOverGameObject())   // make sure not clicking canvas
     {
         ExpressionPiece selectedExpr = controller.selectedExpression;
         if (selectedExpr == null)
         {
             // Debug.Log("No selected expression to say to this NPC");
         }
         else
         {
             ReceiveExpression(Expression.PLAYER, selectedExpr.expression);
             Destroy(selectedExpr.gameObject);
             controller.HidePointer();
             // scontroller.SetInSpeakingMode(false);
         }
     }
 }
Esempio n. 6
0
    // TODO HEIDI 1/27 fill this in so we can display the sentence an NPC is saying over their head!
    public void FromScratch(Expression expr, Vector3 position)
    {
        this.expression = expr;
        this.arguments  = new ExpressionPiece[expr.GetNumArgs()];
        this.gameObject.transform.position = position;
        GameObject tabletop = GameObject.Find("Workspace");

        this.gameObject.transform.position = new Vector3(0, 0, 0);
        // this.gameObject.transform.SetParent = this.parent.transform;

        if (arguments.Length > 0)
        {
            this.heightInUnits = 2;
        }

        int currentXInUnits = 1;

        for (int i = 0; i < arguments.Length; i++)
        {
            Expression argExpression = expr.GetArg(i);

            if (argExpression == null)
            {
                this.widthInUnits++;
                currentXInUnits++;
            }
            else
            {
                GameObject      exprPiece         = Resources.Load("Piece") as GameObject;
                GameObject      exprPieceInstance = Instantiate(exprPiece, new Vector2(0, 0), Quaternion.identity) as GameObject;
                ExpressionPiece exprPieceScript   = exprPieceInstance.GetComponent <ExpressionPiece>();
                // exprPieceScript.gameObject.parent = this;
                exprPieceScript.FromScratch(argExpression, new Vector3(currentXInUnits * PIXELS_PER_UNIT, PIXELS_PER_UNIT));
                arguments[i] = exprPieceScript;

                currentXInUnits   += arguments[i].widthInUnits;
                this.widthInUnits += exprPieceScript.widthInUnits;
                this.heightInUnits = (arguments[i].heightInUnits + 1 > this.heightInUnits) ? arguments[i].heightInUnits + 1 : this.heightInUnits;
            }
        }
    }
Esempio n. 7
0
    public IEnumerator ShowSpeechBubble(Expression expr)
    {
        GameObject exprPiece         = Resources.Load("Piece") as GameObject;
        GameObject exprPieceInstance = Instantiate(exprPiece, new Vector2(0, 0), Quaternion.identity) as GameObject;

        exprPieceInstance.name = "LIONKING";
        ExpressionPiece exprPieceScript = exprPieceInstance.GetComponent <ExpressionPiece>();

        exprPieceScript.FromScratch(expr, new Vector3(0, 0, 0));
        exprPieceScript.transform.SetParent(GameObject.Find("ResponseCanvas").transform);

        Camera cam;

        if (controller.is2D)
        {
            cam = GameObject.Find("Main Camera").GetComponent <Camera>();
            exprPieceScript.transform.position = cam.WorldToScreenPoint(this.transform.position);
            exprPieceScript.transform.position =
                new Vector3(exprPieceScript.transform.position.x,
                            exprPieceScript.transform.position.y +
                            (exprPieceScript.heightInUnits * ExpressionPiece.PIXELS_PER_UNIT / 2) +
                            16);
        }
        else
        {
            cam = GameObject.Find("FirstPersonCharacter").GetComponent <Camera>();
            exprPieceScript.transform.position = cam.WorldToScreenPoint(this.transform.position);
            exprPieceScript.transform.position =
                new Vector3(exprPieceScript.transform.position.x,
                            exprPieceScript.transform.position.y +
                            (exprPieceScript.heightInUnits * ExpressionPiece.PIXELS_PER_UNIT / 2));
        }

        exprPieceScript.SetVisual(exprPieceScript.GenerateVisual());
        Destroy(exprPieceInstance, 2.0f);
        yield return(new WaitForSeconds(2.0f));
    }
Esempio n. 8
0
    void Update()
    {
        if (Input.GetMouseButtonDown(1) || Input.GetKeyDown(KeyCode.F))
        {
            if (currentUseObject != null)
            {
                currentUseObject.transform.parent = null;
                currentUseObject = null;
            }
        }

        if (Input.GetKeyDown(KeyCode.Alpha0))
        {
            Debug.Log("0 pressed");
            if (currentInteractObject != null)
            {
                GameObject thatInventory   = GameObject.Find(currentInteractObject.name + "/Inventory");
                GameObject playerInventory = GameObject.Find("FPSController/Inventory");
                if (thatInventory != null && playerInventory.transform.childCount > 0)
                {
                    Transform item = playerInventory.transform.GetChild(0);
                    item.transform.SetParent(thatInventory.transform);
                    item.transform.position = thatInventory.transform.position;
                }
            }
        }

        if (Input.GetKeyUp(KeyCode.Tab))
        {
            if (selectedExpression != null)
            {
                if (!is2D)
                {
                    selectedExpression.transform.SetParent(GameObject.Find("ScreenCanvas").transform);
                    selectedExpression.transform.position = new Vector3(Screen.width / 2, Screen.height / 2);
                    usableExpression = selectedExpression;
                    // selectedExpression = null;
                }
                HidePointer();
                selectedExpression = null;
            }

            canvas.SetActive(!canvas.activeInHierarchy);
            if (fpc)
            {
                FirstPersonController fpcScript = fpc.GetComponent <FirstPersonController>();
                if (canvas.activeInHierarchy)
                {
                    fpcScript.enabled = false;
                    highClick.Play();
                }
                else
                {
                    fpcScript.enabled = true;
                    Cursor.lockState  = CursorLockMode.Locked;
                    Cursor.visible    = false;
                    lowClick.Play();
                }
            }
        }

        if (Input.GetKeyDown(KeyCode.Escape))
        {
            Application.Quit();
        }
    }
 /**
  * When the user tries to drag this ExpressionPieceSpawner, an ExpressionPiece
  * will get created based on the name of this ExpressionPieceSpawner.
  */
 void IPointerClickHandler.OnPointerClick(PointerEventData eventData)
 {
     ExpressionPiece exprPiece = MakeNewExpressionPiece();
 }
Esempio n. 10
0
    private GameObject GenerateVisual(bool isFirstLevel)
    {
        GameObject exprPiece = this.gameObject;

        RectTransform pieceRect        = exprPiece.GetComponent <RectTransform>();
        float         calculatedWidth  = PIXELS_PER_UNIT * this.widthInUnits;
        float         calculatedHeight = PIXELS_PER_UNIT * this.heightInUnits;

        pieceRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, calculatedWidth);
        pieceRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, calculatedHeight);

        float pieceCenterX  = 0;
        float pieceCenterY  = 0;
        float pieceTopLeftX = pieceCenterX - calculatedWidth / 2;
        float pieceTopLeftY = pieceCenterY + calculatedHeight / 2;

        GameObject visualContainer = new GameObject();

        visualContainer.name = "VisualContainer";
        visualContainer.transform.SetParent(exprPiece.transform);
        visualContainer.layer = 0;

        RectTransform visContainerRectTransform = visualContainer.AddComponent <RectTransform>();

        visContainerRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, calculatedWidth - BUFFER_IN_PIXELS);
        visContainerRectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, calculatedHeight - BUFFER_IN_PIXELS);

        if (DRAW_SUBEXPRESSION_TYPE || this.expression.headString.Equals("_") || isFirstLevel)
        {
            Image bgImage = visualContainer.AddComponent <Image>();
            bgImage.color = isFirstLevel ? this.expression.type.outputColor : this.expression.type.color + new Color(0.25f, 0.25f, 0.25f, 0f) - new Color(0, 0, 0, (1 - EXPRESSION_OPACITY));

            Color borderColor = this.expression.type.color;

            GenerateBorder(borderColor, visualContainer, calculatedWidth, calculatedHeight, "North");
            GenerateBorder(borderColor, visualContainer, calculatedWidth, calculatedHeight, "South");
            GenerateBorder(borderColor, visualContainer, calculatedWidth, calculatedHeight, "West");
            GenerateBorder(borderColor, visualContainer, calculatedWidth, calculatedHeight, "East");
        }

        GameObject headObject = new GameObject();

        headObject.name = "Head";
        headObject.transform.SetParent(visualContainer.transform);
        Image      headImage = headObject.AddComponent <Image>();
        Expression expr      = this.expression;
        // Sprite headSprite = Resources.Load<Sprite>("Symbols/" + expr.headString);
        Sprite headSprite = Resources.Load <Sprite>("English/" + expr.headString);

        if (headSprite == null)
        {
            headSprite = Resources.Load <Sprite>("PlaceholderSprites/" + expr.headString);
        }
        headImage.sprite = headSprite;
        headImage.transform.localScale *= .25f;
        headImage.transform.position    = new Vector3(pieceTopLeftX + (.5f * PIXELS_PER_UNIT), pieceTopLeftY - (.5f * PIXELS_PER_UNIT));

        visualContainer.transform.position = new Vector3(0, 0, 0);

        int numArgs  = this.arguments.Length;
        int currentX = 1; //in units
        int currentY = 1;

        for (int i = 0; i < numArgs; i++)
        {
            ExpressionPiece arg = this.arguments[i];

            if (arg == null)
            {
                currentX++;
            }
            else
            {
                currentX += arg.widthInUnits;

                float positionX         = pieceTopLeftX + PIXELS_PER_UNIT * (currentX - ((.5f * arg.widthInUnits) + BUFFER_IN_UNITS));
                float valToTopAlignArgs = (((this.heightInUnits - 1) - arg.heightInUnits)) * (PIXELS_PER_UNIT / 2);
                float positionY         = PIXELS_PER_UNIT * ((-0.5f * currentY) + BUFFER_IN_UNITS) + valToTopAlignArgs;

                if (arg.id.Equals("_") && !isFirstLevel)
                {
                    arg.expression = new Word(arg.expression.type, "blank");
                }
                GameObject argVisual = arg.GenerateVisual(false);
                argVisual.transform.SetParent(visualContainer.transform);
                argVisual.transform.position = new Vector3(positionX, positionY);
            }
        }
        return(visualContainer);
    }
Esempio n. 11
0
 public void SetParentExpressionPiece(ExpressionPiece parent)
 {
     parentExpressionPiece = parent;
 }
Esempio n. 12
0
    /**
     * returns false if 2 expressions shouldn't combine with each other
     */
    public bool CombineWith(ExpressionPiece inputExpression, int index)
    {
        Expression expr = null;

        //try to create new Expression
        try {
            expr = new Phrase(this.expression, inputExpression.expression, index);
        } catch (Exception e) {
            Debug.LogException(e);
            this.gameController.failure.Play();
            return(false);
        }

        // generate new Piece
        GameObject      exprPiece         = Resources.Load("Piece") as GameObject;
        GameObject      exprPieceInstance = Instantiate(exprPiece, GetSpawnPosition(), Quaternion.identity) as GameObject;
        ExpressionPiece exprPieceScript   = exprPieceInstance.GetComponent <ExpressionPiece>();

        exprPieceScript.expression = expr;
        exprPieceScript.arguments  = new ExpressionPiece[expr.GetNumArgs()];

        if (exprPieceScript.arguments.Length > 0)
        {
            exprPieceScript.heightInUnits = 2;
        }

        float originalPieceX = this.transform.position.x;
        float originalPieceY = this.transform.position.y;

        // exprPieceInstance.transform.position = new Vector3(originalPieceX, originalPieceY, 0);

        exprPieceScript.gameController = gameController;
        exprPieceScript.id             = expr.ToString();

        exprPieceScript.index = this.index;

        if (this.parentExpressionPiece != null)
        {
            exprPieceScript.SetParentExpressionPiece(this.parentExpressionPiece.DeepCopy()); // DeepCopy here bc 'this' will get destroyed
        }

        // int noArgInputWidth = 1;
        // int noArgInputHeight = 1;

        // for (int i = 0; i < inputExpression.arguments.Legth; i++) {
        //     if (!inputExpression[i].id.Equals("_")) {
        //         noArgInputWidth += inputExpression[i].widthInUnits;
        //         noArgInputHeight = Max(noArgInputHeight, inputExpression.heightInUnits + 1);
        //     }
        // }

        exprPieceScript.widthInUnits  = 1;
        exprPieceScript.widthInUnits += inputExpression.widthInUnits;

        exprPieceScript.heightInUnits = Max(exprPieceScript.heightInUnits, inputExpression.heightInUnits + 1);

        //Add the arguments to the new piece
        int counter = -1;

        for (int i = 0; i < arguments.Length; i++)
        {
            if (this.arguments[i] == null)
            {
                counter++;
                exprPieceScript.widthInUnits++;
            }
            else
            {
                // this happens to every argument, whether blank or filled
                float originalArgLocalX = this.arguments[i].transform.localPosition.x;
                float originalArgLocalY = this.arguments[i].transform.localPosition.y;

                // place a copy of the old argument in the same position in the new expression.
                exprPieceScript.arguments[i] = this.arguments[i].DeepCopy();
                exprPieceScript.arguments[i].transform.SetParent(exprPieceInstance.transform);
                exprPieceScript.arguments[i].gameObject.transform.localPosition = new Vector3(originalArgLocalX, originalArgLocalY, 0);

                // changing the width and height of the new expression
                exprPieceScript.widthInUnits += exprPieceScript.arguments[i].widthInUnits;
                exprPieceScript.heightInUnits = Max(exprPieceScript.heightInUnits, exprPieceScript.arguments[i].heightInUnits + 1);

                // if it's an empty argument slot, then move forward in the
                // argument index, and decrement the argument slot's index by 1 if
                // the argument has already been placed to preserve the new indexing.
                if (this.arguments[i].id.Equals("_"))
                {
                    if (counter > index)
                    {
                        exprPieceScript.arguments[i].index--;
                    }
                    counter++;
                }
            }

            // place the input expression in the appropriate argument position.
            if (counter == index)
            {
                float originalArgLocalX = this.arguments[i].transform.localPosition.x;
                float originalArgLocalY = this.arguments[i].transform.localPosition.y;

                //need to destroy the empty arg that this piece is replacing
                Destroy(exprPieceScript.arguments[i].gameObject, 0.0f);

                exprPieceScript.arguments[i] = inputExpression.DeepCopy();
                exprPieceScript.arguments[i].gameObject.transform.localPosition =
                    new Vector3(originalArgLocalX, originalArgLocalY, 0);
                exprPieceScript.arguments[i].transform.SetParent(exprPieceInstance.transform);

                counter++;
                exprPieceScript.widthInUnits--;
            }
        }

        int xPositionInUnits = 1;

        // this is setting the parentexpressionpiece and parent of all of the new
        // expression's arguments as the new expression. This doesn't happen in
        // deepcopy because deepcopy makes a new copy of the expression to set.
        for (int i = 0; i < arguments.Length; i++)
        {
            float argLocalX = exprPieceScript.arguments[i].transform.localPosition.x;
            float argLocalY = exprPieceScript.arguments[i].transform.localPosition.y;

            float changeY = ((exprPieceScript.heightInUnits - 2) / 2f) * PIXELS_PER_UNIT;

            if (exprPieceScript.arguments[i].id.Equals("_"))
            {
                exprPieceScript.arguments[i].gameObject.transform.localPosition =
                    new Vector3(
                        ((-0.5f * exprPieceScript.widthInUnits) + xPositionInUnits + 0.5f - BUFFER_IN_UNITS) * PIXELS_PER_UNIT,
                        argLocalY + changeY);
            }

            exprPieceScript.arguments[i].SetParentExpressionPiece(exprPieceScript);
            exprPieceInstance.transform.SetParent(this.transform.parent.transform);

            // Debug.Log(exprPieceScript.expression + "'s width is " + exprPieceScript.widthInUnits);
            // Debug.Log(exprPieceScript.expression + "[" + i + "]'s width is " + arguments[i].widthInUnits);
            xPositionInUnits += exprPieceScript.arguments[i].widthInUnits;
        }

        exprPieceInstance.transform.SetParent(this.transform.parent.transform);
        exprPieceScript.SetVisual(exprPieceScript.GenerateVisual());

        int indexToOccupy = this.gameObject.transform.GetSiblingIndex();

        // foreach (ExpressionPiece arg in this.arguments) {
        //     Destroy(arg.gameObject, 0.0f);
        // }

        Destroy(this.gameObject, 0.0f);
        // the arguments to the input expression aren't being destroyed properly. They're just floating around
        Destroy(inputExpression.gameObject, 0.0f);

        exprPiece.transform.SetSiblingIndex(indexToOccupy);

        return(true);
    }