Esempio n. 1
0
    public void TargetSetStartData(NetworkConnection target, int life, int gold, int cannonLeft, int cannonRight, float speed, Vector3 position, Vector4 rotation, int level, bool harpoon)
    {
        this.data.Ressource.Golds        = gold;
        this.data.Ressource.BoatLevel    = level;
        this.data.Boat.Stats.Life        = life;
        this.data.Boat.CurrentCanonLeft  = cannonLeft;
        this.data.Boat.CurrentCanonRight = cannonRight;
        this.data.Boat.Stats.Speed       = speed;
        this.data.Boat.AsHarpoon         = harpoon;// SEB 0910

        //SEB 08
        myVector3 pos = new myVector3();

        pos.x = position.x;
        pos.y = position.y;
        pos.z = position.z;
        this.data.Boat.Transform.Position = pos;

        myVector4 rot = new myVector4();

        rot.x = 0;
        rot.y = rotation.y;
        rot.z = 0;
        rot.w = 0;
        this.data.Boat.Transform.Rotation = rot;
        //FIN SEB 08
    }
Esempio n. 2
0
    public void SaveObjects(string levelType, int levelNum)
    {
        var sep = "/";

        Debug.Log("Save Objects to " + Statics.folderPath + levelType + sep + "level" + levelNum + ".dat");
        levelObjects = new LevelObjects();
        string folderPath = Statics.folderPath + levelType + sep;
        string filePath   = folderPath + "level" + levelNum + ".dat";
        var folder        = Directory.CreateDirectory(folderPath);

        ScreenCapture.CaptureScreenshot(folderPath + "level" + levelNum + ".png");
        Debug.Log("Save Dots");
        for (int i = 0; i < dots.Count; i++)
        {
            myVector3 position = dots[i].transform.position;
            levelObjects.dotPositions.Add(position);
            levelObjects.dotForwards.Add(dots[i].transform.forward);
            var color = dots[i].GetComponent <SpriteRenderer> ().color;
            levelObjects.dotColors.Add("#" + ColorUtility.ToHtmlStringRGB(color));
        }
        Debug.Log("Save Paths");
        for (int i = 0; i < paths.Count; i++)
        {
            Debug.Log("Save Path " + i);
            levelObjects.paths.Add(new List <myVector3> ());
            levelObjects.normals.Add(new List <myVector3> ());
            var path = paths[i];
            for (int k = 0; k < path.Count; k++)
            {
                levelObjects.paths[i].Add(path.GetPosition(k));
            }
            for (int k = 0; k < path.GetNormals().Count; k++)
            {
                levelObjects.normals[i].Add(path.GetNormal(k));
            }
            var color = paths[i].GetColor();
            levelObjects.pathColors.Add("#" + ColorUtility.ToHtmlStringRGB(color));
            Debug.Log("Save From: " + path.dotFrom + " at " + dots.IndexOf(path.dotFrom));
            levelObjects.dotsFrom.Add(dots.IndexOf(path.dotFrom));
            Debug.Log("Save To: " + path.dotTo + " at " + dots.IndexOf(path.dotTo));
            levelObjects.dotsTo.Add(dots.IndexOf(path.dotTo));
        }

        //		Debug.Log ("Save Homotopies");

        Debug.Log("Save Statics");
        for (int i = 0; i < statics.Count; i++)
        {
            Debug.Log("Save Static " + i);
            levelObjects.statics.Add(new myStatic(statics[i]));
        }
        FileStream fs      = new FileStream(filePath, FileMode.Create);
        BinaryFormatter bf = new BinaryFormatter();

        bf.Serialize(fs, levelObjects);
        fs.Close();
    }
Esempio n. 3
0
    //1= circle, 0 = rect

    public myStatic(GameObject obj)
    {
        position = obj.transform.position;
        size     = obj.transform.localScale;
        if (obj.GetComponent <Collider> ().GetType() == typeof(SphereCollider))
        {
            type = 1;
        }
        else if (obj.GetComponent <Collider> ().GetType() == typeof(BoxCollider))
        {
            type = 0;
        }
        else
        {
            type = 0;
        }
    }
Esempio n. 4
0
    private bool LoadObjects(int levelNum)
    {
        Debug.Log("Load Objects for level " + levelNum + " for leveltype " + Statics.levelType);
        var    sep        = "/";
        string folderPath = Statics.folderPath + Statics.levelType + sep;
        string filePath   = folderPath + "level" + levelNum + ".dat";

        Debug.Log("Load from " + filePath);
        if (File.Exists(filePath))
        {
            using (Stream stream = File.Open(filePath, FileMode.Open)) {
                var bformatter = new BinaryFormatter();
                levelObjects = (LevelObjects)bformatter.Deserialize(stream);
                var numDots = levelObjects.dotColors.Count;
                Debug.Log("Load Dots: " + numDots);
                for (int i = 0; i < numDots; i++)
                {
                    Color color;
                    ColorUtility.TryParseHtmlString(levelObjects.dotColors[i], out color);
                    myColors.Remove(color);
                    var dot = Instantiate(dotPrefab);
                    dot.transform.position = levelObjects.dotPositions[i];
                    dot.transform.forward  = levelObjects.dotForwards[i];
                    dot.GetComponent <SpriteRenderer> ().color = color;
                    dot.GetComponentInChildren <TrailRenderer> ().Clear();
                    dot.GetComponent <SpriteRenderer> ().sortingOrder = 10;
                    addDot(dot);
                }
                Debug.Log("Load Paths: " + levelObjects.paths.Count);
                for (int i = 0; i < levelObjects.paths.Count; i++)
                {
                    Debug.Log("Load Path " + i);
                    Color color;
                    ColorUtility.TryParseHtmlString(levelObjects.pathColors[i], out color);
                    myColors.Remove(color);
                    var dotNumber1 = levelObjects.dotsFrom[i];
                    var dotNumber2 = levelObjects.dotsTo[i];
                    var path       = NewPath(dots[dotNumber1], dots[dotNumber2]);
                    var loadedPath = levelObjects.paths[i];
                    for (int j = 0; j < loadedPath.Count; j++)
                    {
                        path.SetPosition(j, loadedPath[j]);
                    }
                    List <Vector3> list = new List <Vector3> ();
                    for (int i1 = 0; i1 < levelObjects.normals[i].Count; i1++)
                    {
                        myVector3 normal = levelObjects.normals[i][i1];
                        list.Add(normal);
                        // Debug.DrawLine (path.GetPosition (i1), path.GetPosition (i1) + normal, Color.red, 1000f);
                    }
                    path.SetNormals(list);
                    path.SetMesh();
                    addPath(path);
                }

                Debug.Log("Load Statics: " + levelObjects.statics.Count);
                for (int i = 0; i < levelObjects.statics.Count; i++)
                {
                    Debug.Log("Load Static " + i);
                    var        myStatic = levelObjects.statics[i];
                    GameObject gameObject;
                    if (myStatic.type == 0)
                    {
                        gameObject = GameObject.Instantiate(staticRectPrefab);
                    }
                    else if (myStatic.type == 1)
                    {
                        gameObject = GameObject.Instantiate(staticCirclePrefab);
                    }
                    else
                    {
                        gameObject = GameObject.Instantiate(staticRectPrefab);
                    }
                    gameObject.transform.position   = myStatic.position;
                    gameObject.transform.localScale = myStatic.size;
                    statics.Add(gameObject);

                    if (Statics.showingAlgebra)
                    {
                        AddStaticAlgebra(i, gameObject);
                    }
                }

                for (int i = 0; i < paths.Count; i++)
                {
                    for (int j = i + 1; j < paths.Count; j++)
                    {
                        CheckIfHomotopic(i, j);
                    }
                }
            }
        }
        return(true);
    }