logo
Khóa học lập trình game server - smartfox - game đa người chơi Học lập trinh game online 3dvietpro Sửa chữa và thiết kế website .net
Welcome Guest! To enable all features please Đăng nhập or Đăng ký.

Thông báo

Icon
Error

Tùy chọn
Xem
Xem bài viết cuối Go to first unread
admin  
#1 Đã gửi : 15/05/2019 lúc 07:47:33(UTC)
admin

Danh hiệu: Administration

Nhóm:
Gia nhập: 19-08-2014(UTC)
Bài viết: 146

Được cảm ơn: 7 lần trong 6 bài viết
Unity có nhiều cách dùng để lưu trữ dữ liệu tạm thời trên thiết bị, như: sử dụng lưu dạng file, lưu trên biến PlayerPrefs, dưới đây mình chia sẻ các bạn sử dụng plugin easy save rất phổ biến để lưu dữ liệu, dưới dạng json.

Nếu bạn chưa quen với json mình cũng có 1 vài bài hướng dẫn các bạn hiểu thêm link tại:


https://hocunity.3dvietpro.vn/de...posts&t=297#post5326

https://hocunity.3dvietpro.vn/de...posts&t=282#post4138

Bước 1: Các bạn phải có plugin save easy, plugin này hiện tại dang bán 15$, mình sẽ cung cấp các bạn ở phần dưới.

Bước 2: Các bạn kéo plugin vào unity


Bước 3: kéo file minijson để code được dữ liệu kiểu json

Bước 4: mình đã thực hiện thao tác, thêm, sửa, xóa các phần tử trong mảng list rồi đọc dữ liệu từ file json ra dưới dạng sử dụng công cụ easy save


Video Hướng dẫn sơ lược mình đã làm, các bạn xem nhé,



Code Mình thực hiện

Trích dẫn:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using UnityEngine.UI;
using MiniJSON;
//Khoi tao 1 mang list chua cac gia tri doc tu file info
public class DataYT{
public string id {get; set;}
public string ten {get;set;}
public string link {get;set;}
}

public class SaveYT : MonoBehaviour {

List<DataYT> lstDatYTs ;
// Use this for initialization
void Start () {
//lay du lieu json
string saveString = GetDataJson();
//Thực hiện trên nền tảng IOS và window
if (Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.WindowsEditor)
{
//luu gia tri json vao file info nam trong thu muc resources
ES2.Save(saveString, Application.dataPath + "/Resources/info.txt");
}

//Ham doc du lieu json tu file info
ReadDataJsonFile();
//Ham xoa 1 phan tu
DeleteDataJson("tuanha");
//Ham hien thi du lieu
ShowJsonData();

//Thuc hien them moi du lieu
DataYT newdata = new DataYT();
newdata.id="2";
newdata.ten="tuan hoang";
newdata.link="abcd";
AddJsonData(newdata);
Debug.Log("-------------------------------------");
ShowJsonData();
}

// Update is called once per frame
void Update () {

}
public string GetDataJson()
{

//Khoi tao du lieu tinh theo cau truc json
string str = "[\n";
//dong 1
str += "{";
str += "\"id\":\"1\"";
str += ",";
str += "\"ten\":\"trinh\"";
str += ",";
str += "\"link\":\"https://www.facebook.com/\"";
str += "}";
str += ",\n";
//dong 2
str += "{";
str += "\"id\":\"2\"";
str += ",";
str += "\"ten\":\"tuanha\"";
str += ",";
str += "\"link\":\"https://www.google.com/\"";
str += "}";
str += ",\n";
//dong 3
str += "{";
str += "\"id\":\"3\"";
str += ",";
str += "\"ten\":\"trinh\"";
str += ",";
str += "\"link\":\"https://www.vnexpress.com/\"";
str += "}";
str += ",\n";

str += "\n]";
return str;

}

public void ReadDataJsonFile()
{
string levelText = ES2.Load<string>(Application.dataPath + "/Resources/info.txt");
//su dung thu vien MiniJSON de doc du lieu json dua vao mang list
List<object> jsonArr =Json.Deserialize(levelText) as List<object>;

lstDatYTs = new List<DataYT>();
for (int i = 0; i < jsonArr.Count; i++)
{
DataYT newObj = new DataYT();
Dictionary<string, object> dicData = jsonArr[i] as Dictionary<string, object>;
newObj.id = (string)dicData["id"];
newObj.ten = (string)dicData["ten"];
newObj.link = (string)dicData["link"];

//mang list lstDatYT chua du lieu duoc xu ly, tuy thuoc vao ban sau nay
//muon su dung no
lstDatYTs.Add(newObj);
}

}

public void DeleteDataJson(string ten)
{
//Khi xoa phan tu nao do trong mang list ban phai duyet tu phan tu cuoi
for(int n= lstDatYTs.Count-1;n>=0;n--)
{
if(lstDatYTs[n].ten.Contains(ten))
{
//su dung removeat xoa phan tu thu "n"
lstDatYTs.RemoveAt(n);
}
}
}
//Thuc hien show du lieu trong mang lstDatYts
public void ShowJsonData()
{
//in gia tri
foreach(var item in lstDatYTs)
{
Debug.Log("id:" + item.id + "*ten:" + item.ten + "*link:" +item.link);
}
}
//them 1 dong du lieu
public void AddJsonData(DataYT newdata)
{
lstDatYTs.Add(newdata);
}
}

/***
Luu ý:
+ Viec su dung easysave giup ban quanr ly du lieu tot tren client, khi ban muon luu tru du lieu
+ Mang lstDatYts se chua du lieu duoc do ra tu file easysave


***/









File MiniJson

Trích dẫn:
/*
* Copyright (c) 2013 Calvin Rien
*
* Based on the JSON parser by Patrick van Bergen
* http://techblog.procurio...own-parser-for-JSON.html
*
* Simplified it so that it doesn't throw exceptions
* and can be used in Unity iPhone with maximum code stripping.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;

namespace MiniJSON {
// Example usage:
//
// using UnityEngine;
// using System.Collections;
// using System.Collections.Generic;
// using MiniJSON;
//
// public class MiniJSONTest : MonoBehaviour {
// void Start () {
// var jsonString = "{ \"array\": [1.44,2,3], " +
// "\"object\": {\"key1\":\"value1\", \"key2\":256}, " +
// "\"string\": \"The quick brown fox \\\"jumps\\\" over the lazy dog \", " +
// "\"unicode\": \"\\u3041 Men\u00fa sesi\u00f3n\", " +
// "\"int\": 65536, " +
// "\"float\": 3.1415926, " +
// "\"bool\": true, " +
// "\"null\": null }";
//
// var dict = Json.Deserialize(jsonString) as Dictionary<string,object>;
//
// Debug.Log("deserialized: " + dict.GetType());
// Debug.Log("dict['array'][0]: " + ((List<object>) dict["array"])[0]);
// Debug.Log("dict['string']: " + (string) dict["string"]);
// Debug.Log("dict['float']: " + (double) dict["float"]); // floats come out as doubles
// Debug.Log("dict['int']: " + (long) dict["int"]); // ints come out as longs
// Debug.Log("dict['unicode']: " + (string) dict["unicode"]);
//
// var str = Json.Serialize(dict);
//
// Debug.Log("serialized: " + str);
// }
// }

/// <summary>
/// This class encodes and decodes JSON strings.
/// Spec. details, see http://www.json.org/
///
/// JSON uses Arrays and Objects. These correspond here to the datatypes IList and IDictionary.
/// All numbers are parsed to doubles.
/// </summary>
public static class Json {
/// <summary>
/// Parses the string json into a value
/// </summary>
/// <param name="json">A JSON string.</param>
/// <returns>An List&lt;object&gt;, a Dictionary&lt;string, object&gt;, a double, an integer,a string, null, true, or false</returns>
public static object Deserialize(string json) {
// save the string for debug information
if (json == null) {
return null;
}

return Parser.Parse(json);
}

sealed class Parser : IDisposable {
const string WORD_BREAK = "{}[],:\"";

public static bool IsWordBreak(char c) {
return Char.IsWhiteSpace(c) || WORD_BREAK.IndexOf(c) != -1;
}

enum TOKEN {
NONE,
CURLY_OPEN,
CURLY_CLOSE,
SQUARED_OPEN,
SQUARED_CLOSE,
COLON,
COMMA,
STRING,
NUMBER,
TRUE,
FALSE,
NULL
};

StringReader json;

Parser(string jsonString) {
json = new StringReader(jsonString);
}

public static object Parse(string jsonString) {
using (var instance = new Parser(jsonString)) {
return instance.ParseValue();
}
}

public void Dispose() {
json.Dispose();
json = null;
}

Dictionary<string, object> ParseObject() {
Dictionary<string, object> table = new Dictionary<string, object>();

// ditch opening brace
json.Read();

// {
while (true) {
switch (NextToken) {
case TOKEN.NONE:
return null;
case TOKEN.COMMA:
continue;
case TOKEN.CURLY_CLOSE:
return table;
default:
// name
string name = ParseString();
if (name == null) {
return null;
}

// :
if (NextToken != TOKEN.COLON) {
return null;
}
// ditch the colon
json.Read();

// value
table[name] = ParseValue();
break;
}
}
}

List<object> ParseArray() {
List<object> array = new List<object>();

// ditch opening bracket
json.Read();

// [
var parsing = true;
while (parsing) {
TOKEN nextToken = NextToken;

switch (nextToken) {
case TOKEN.NONE:
return null;
case TOKEN.COMMA:
continue;
case TOKEN.SQUARED_CLOSE:
parsing = false;
break;
default:
object value = ParseByToken(nextToken);

array.Add(value);
break;
}
}

return array;
}

object ParseValue() {
TOKEN nextToken = NextToken;
return ParseByToken(nextToken);
}

object ParseByToken(TOKEN token) {
switch (token) {
case TOKEN.STRING:
return ParseString();
case TOKEN.NUMBER:
return ParseNumber();
case TOKEN.CURLY_OPEN:
return ParseObject();
case TOKEN.SQUARED_OPEN:
return ParseArray();
case TOKEN.TRUE:
return true;
case TOKEN.FALSE:
return false;
case TOKEN.NULL:
return null;
default:
return null;
}
}

string ParseString() {
StringBuilder s = new StringBuilder();
char c;

// ditch opening quote
json.Read();

bool parsing = true;
while (parsing) {

if (json.Peek() == -1) {
parsing = false;
break;
}

c = NextChar;
switch (c) {
case '"':
parsing = false;
break;
case '\\':
if (json.Peek() == -1) {
parsing = false;
break;
}

c = NextChar;
switch (c) {
case '"':
case '\\':
case '/':
s.Append(c);
break;
case 'b':
s.Append('\b');
break;
case 'f':
s.Append('\f');
break;
case 'n':
s.Append('\n');
break;
case 'r':
s.Append('\r');
break;
case 't':
s.Append('\t');
break;
case 'u':
var hex = new char[4];

for (int i=0; i< 4; i++) {
hex[i] = NextChar;
}

s.Append((char) Convert.ToInt32(new string(hex), 16));
break;
}
break;
default:
s.Append(c);
break;
}
}

return s.ToString();
}

object ParseNumber() {
string number = NextWord;

if (number.IndexOf('.') == -1) {
long parsedInt;
Int64.TryParse(number, out parsedInt);
return parsedInt;
}

double parsedDouble;
Double.TryParse(number, out parsedDouble);
return parsedDouble;
}

void EatWhitespace() {
while (Char.IsWhiteSpace(PeekChar)) {
json.Read();

if (json.Peek() == -1) {
break;
}
}
}

char PeekChar {
get {
return Convert.ToChar(json.Peek());
}
}

char NextChar {
get {
return Convert.ToChar(json.Read());
}
}

string NextWord {
get {
StringBuilder word = new StringBuilder();

while (!IsWordBreak(PeekChar)) {
word.Append(NextChar);

if (json.Peek() == -1) {
break;
}
}

return word.ToString();
}
}

TOKEN NextToken {
get {
EatWhitespace();

if (json.Peek() == -1) {
return TOKEN.NONE;
}

switch (PeekChar) {
case '{':
return TOKEN.CURLY_OPEN;
case '}':
json.Read();
return TOKEN.CURLY_CLOSE;
case '[':
return TOKEN.SQUARED_OPEN;
case ']':
json.Read();
return TOKEN.SQUARED_CLOSE;
case ',':
json.Read();
return TOKEN.COMMA;
case '"':
return TOKEN.STRING;
case ':':
return TOKEN.COLON;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case '-':
return TOKEN.NUMBER;
}

switch (NextWord) {
case "false":
return TOKEN.FALSE;
case "true":
return TOKEN.TRUE;
case "null":
return TOKEN.NULL;
}

return TOKEN.NONE;
}
}
}

/// <summary>
/// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string
/// </summary>
/// <param name="json">A Dictionary&lt;string, object&gt; / List&lt;object&gt;</param>
/// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
public static string Serialize(object obj) {
return Serializer.Serialize(obj);
}

sealed class Serializer {
StringBuilder builder;

Serializer() {
builder = new StringBuilder();
}

public static string Serialize(object obj) {
var instance = new Serializer();

instance.SerializeValue(obj);

return instance.builder.ToString();
}

void SerializeValue(object value) {
IList asList;
IDictionary asDict;
string asStr;

if (value == null) {
builder.Append("null");
} else if ((asStr = value as string) != null) {
SerializeString(asStr);
} else if (value is bool) {
builder.Append((bool) value ? "true" : "false");
} else if ((asList = value as IList) != null) {
SerializeArray(asList);
} else if ((asDict = value as IDictionary) != null) {
SerializeObject(asDict);
} else if (value is char) {
SerializeString(new string((char) value, 1));
} else {
SerializeOther(value);
}
}

void SerializeObject(IDictionary obj) {
bool first = true;

builder.Append('{');

foreach (object e in obj.Keys) {
if (!first) {
builder.Append(',');
}

SerializeString(e.ToString());
builder.Append(':');

SerializeValue(obj[e]);

first = false;
}

builder.Append('}');
}

void SerializeArray(IList anArray) {
builder.Append('[');

bool first = true;

foreach (object obj in anArray) {
if (!first) {
builder.Append(',');
}

SerializeValue(obj);

first = false;
}

builder.Append(']');
}

void SerializeString(string str) {
builder.Append('\"');

char[] charArray = str.ToCharArray();
foreach (var c in charArray) {
switch (c) {
case '"':
builder.Append("\\\"");
break;
case '\\':
builder.Append("\\\\");
break;
case '\b':
builder.Append("\\b");
break;
case '\f':
builder.Append("\\f");
break;
case '\n':
builder.Append("\\n");
break;
case '\r':
builder.Append("\\r");
break;
case '\t':
builder.Append("\\t");
break;
default:
int codepoint = Convert.ToInt32(c);
if ((codepoint >= 32) && (codepoint <= 126)) {
builder.Append(c);
} else {
builder.Append("\\u");
builder.Append(codepoint.ToString("x4"));
}
break;
}
}

builder.Append('\"');
}

void SerializeOther(object value) {
// NOTE: decimals lose precision during serialization.
// They always have, I'm just letting you know.
// Previously floats and doubles lost precision too.
if (value is float) {
builder.Append(((float) value).ToString("R"));
} else if (value is int
|| value is uint
|| value is long
|| value is sbyte
|| value is byte
|| value is short
|| value is ushort
|| value is ulong) {
builder.Append(value);
} else if (value is double
|| value is decimal) {
builder.Append(Convert.ToDouble(value).ToString("R"));
} else {
SerializeString(value.ToString());
}
}
}
}
}


Plugin Save easy các bạn có thể download về:

https://drive.google.com/file/d/...SMI3AFR/view?usp=sharing

Pass: 3dvietpro các bạn nhé


Bạn bình luận ngay tại đây
Ai đang xem chủ đề này?
Guest
Di chuyển  
Bạn không thể tạo chủ đề mới trong diễn đàn này.
Bạn không thể trả lời chủ đề trong diễn đàn này.
Bạn không thể xóa bài của bạn trong diễn đàn này.
Bạn không thể sửa bài của bạn trong diễn đàn này.
Bạn không thể tạo bình chọn trong diễn đàn này.
Bạn không thể bỏ phiếu bình chọn trong diễn đàn này.

Powered by YAF 2.1.0 | YAF © 2003-2019, Yet Another Forum.NET
Thời gian xử lý trang này hết 4.517 giây.


close(x)