private IEnumerable <EmbeddedData> IterateEmbeddedData(
        MessagePackObjectDictionary worldDict, EmbeddedDataType type)
    {
        var typeString = type.ToString();

        foreach (var propList in IterateProperties(worldDict))
        {
            if (!propList[1].IsList)
            {
                continue;
            }
            var dataList = propList[1].AsList();
            if (dataList.Count >= 3 && dataList[1].UnderlyingType == typeof(string) &&
                dataList[1].AsString() == typeString)
            {
                var name  = dataList[0].AsString();
                var bytes = dataList[2].AsBinary();
                yield return(new EmbeddedData(name, bytes, type));
            }
        }
    }
示例#2
0
    public override void WindowGUI()
    {
        if (loadingWorld)
        {
            GUILayout.FlexibleSpace();
            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            GUILayout.Label("Loading world...");
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
            GUILayout.FlexibleSpace();
        }
        else if (!worldSelected)
        {
            scroll = GUILayout.BeginScrollView(scroll);
            GUILayout.BeginHorizontal();
            GUILayout.FlexibleSpace();
            if (GUILayout.Button("Choose a file to open in N-Space", GUIStyleSet.instance.buttonLarge))
            {
                ShareMap.OpenFileManager();
            }
            GUILayout.FlexibleSpace();
            GUILayout.EndHorizontal();
            GUILayout.Label("Or import from a world...");
            for (int i = 0; i < worldPaths.Count; i++)
            {
                string path = worldPaths[i];
                string name = worldNames[i];

                if (GUILayout.Button(name, GUIStyleSet.instance.buttonLarge))
                {
                    worldSelected = true;
                    StartCoroutine(LoadWorldCoroutine(path));
                    scroll         = Vector2.zero;
                    scrollVelocity = Vector2.zero;
                }
            }
            GUILayout.EndScrollView();
        }
        else // world is selected
        {
            if (GUIUtils.HighlightedButton("Back to world list", GUIStyleSet.instance.buttonLarge))
            {
                worldSelected  = false;
                dataList       = null;
                scroll         = Vector2.zero;
                scrollVelocity = Vector2.zero;
                StopPlayer();
            }
            if (dataList != null && dataList.Count > 0)
            {
                foreach (EmbeddedData data in dataList)
                {
                    GUILayout.BeginHorizontal();
                    if (GUILayout.Button(data.name, GUIStyleSet.instance.buttonLarge))
                    {
                        dataAction(data);
                        Destroy(this);
                    }
                    if (playerFactory != null && GUIUtils.HighlightedButton(
                            GUIIconSet.instance.playAudio,
                            GUIStyleSet.instance.buttonLarge,
                            playingData == data,
                            GUILayout.ExpandWidth(false)))
                    {
                        if (StopPlayer() != data)
                        {
                            playingAudio = playerFactory(data.bytes);
                            playingData  = data;
                        }
                    }
                    GUILayout.EndHorizontal();
                }
            }
            else
            {
                GUILayout.BeginHorizontal();
                GUILayout.FlexibleSpace();
                if (errorMessage != null)
                {
                    ActionBarGUI.ActionBarLabel(errorMessage);
                }
                else
                {
                    ActionBarGUI.ActionBarLabel("World contains no " + type.ToString() + " files.");
                }
                GUILayout.FlexibleSpace();
                GUILayout.EndHorizontal();
            }
        }
    }
        private static EmbeddedDataType Decode(Bitmap image, int encodedBits, out byte[] data, out byte[] filename)
        {
            //byte[] mBuff = new byte[(int)Math.Ceiling(image.Width * (double)image.Height / encodedBits)];
            //int bIndex  = 0;
            EmbeddedDataType embeddedDataType = EmbeddedDataType.Unknown;

            byte[]      embeddedFilename = null;
            List <byte> mBuff            = new List <byte>();
            byte        cBuff            = 0;
            int         counter          = 0;

            byte[] matchEndOfDataStream = new byte[EndOfDataStreamSequence.Length];

            bool isFirstByte = true;

            bool AddPart(byte part)
            {
                cBuff = (byte)((cBuff << encodedBits) + part);
                counter++;

                if (counter >= 8 / encodedBits)
                {
                    byte dByte = DecodeByte(cBuff, encodedBits);

addByte:
                    if (isFirstByte)
                    {
                        isFirstByte = false;
                        // try to convert byte to EmbeddedDataType
                        embeddedDataType = (EmbeddedDataType)dByte;
                        if (!Enum.IsDefined(typeof(EmbeddedDataType), embeddedDataType) && !embeddedDataType.ToString().Contains(","))
                        {
                            embeddedDataType = EmbeddedDataType.Message;
                            // The byte was unknown, therefore it must be part of the message
                            goto addByte;
                        }
                        else
                        {
                            // Reset all variables
                            cBuff   = 0;
                            counter = 0;
                        }
                        if (_showDebugInfo)
                        {
                            Console.WriteLine($"Classifies embedded data as: {embeddedDataType.ToString()}...");
                        }
                    }
                    else
                    {
                        // Check for en of transmission
                        if (matchEndOfDataStream.SequenceEqual(EndOfDataStreamSequence)) // Was last byte of message
                        {
                            if (embeddedDataType == EmbeddedDataType.Message)
                            {
                                return(true);
                            }
                            else if (embeddedFilename == null)
                            {
                                embeddedFilename = mBuff.GetRange(0, mBuff.Count - EndOfDataStreamSequence.Length).ToArray();
                                mBuff            = new List <byte>();
                                mBuff.Add(dByte);
                                cBuff   = 0;
                                counter = 0;

                                ShiftAndAddByte(ref matchEndOfDataStream, dByte);
                                return(false);
                            }
                            else
                            {
                                return(true);
                            }
                        }
                        mBuff.Add(dByte);
                        cBuff   = 0;
                        counter = 0;

                        ShiftAndAddByte(ref matchEndOfDataStream, dByte);
                    }
                }
                return(false); // Was not last byte of message
            }

            EmbeddedDataType OnReturn(out byte[] d, out byte[] f)
            {
                d = mBuff.GetRange(0, mBuff.Count - EndOfDataStreamSequence.Length).ToArray();
                f = embeddedFilename;
                return(embeddedDataType);
            }

            for (int h = 0; h < image.Height; h++)
            {
                for (int w = 0; w < image.Width; w++)
                {
                    Color pixel = image.GetPixel(w, h);
                    byte  r     = (byte)(pixel.R ^ ((pixel.R >> encodedBits) << encodedBits));
                    byte  g     = (byte)(pixel.G ^ ((pixel.G >> encodedBits) << encodedBits));
                    byte  b     = (byte)(pixel.B ^ ((pixel.B >> encodedBits) << encodedBits));

                    if (AddPart(r))
                    {
                        return(OnReturn(out data, out filename));
                    }
                    if (AddPart(g))
                    {
                        return(OnReturn(out data, out filename));
                    }
                    if (AddPart(b))
                    {
                        return(OnReturn(out data, out filename));
                    }
                }
            }

            //return message;
            return(OnReturn(out data, out filename));
        }