public BDECL(Stream stream)
{
//try {
stream.Seek(0, SeekOrigin.Begin);
//type
byte[] typeLenBuff = new byte[4];
stream.Read(typeLenBuff, 0, typeLenBuff.Length);
byte[] typeBuff = new byte[BitConverter.ToInt32(typeLenBuff, 0)];
stream.Read(typeBuff, 0, typeBuff.Length);
type = (TYPE)Enum.Parse(typeof(TYPE), Encoding.Default.GetString(typeBuff));
//filename
byte[] filenameLenBuff = new byte[4];
stream.Read(filenameLenBuff, 0, filenameLenBuff.Length);
byte[] filenameBuff = new byte[BitConverter.ToInt32(filenameLenBuff, 0)];
stream.Read(filenameBuff, 0, filenameBuff.Length);
filename = Encoding.Default.GetString(filenameBuff);
//get according method
streamMirror = stream;
string test = type.ToString();
MethodInfo bdeclMethod = this.GetType().GetMethod(type.ToString(), BindingFlags.Instance | BindingFlags.NonPublic);
data = (string)bdeclMethod.Invoke(this, null);
//the caller has to close the stream
/* }
* catch(Exception ex)
* {
* Console.WriteLine("[BDECL] Exception while parsing binary decl:" + ex.Message);
* }*/
}
public async void GetCommentOfStore(TYPEGET typeGet, TYPE type=0)
{
string lastId = "";
int storeId = MediateClass.KiotVM.SelectedStore.StoreId;
if (typeGet == TYPEGET.MORE)
{
if (CommentLstOfStore.Count != 0)
{
if (type == TYPE.OLD)
lastId = CommentLstOfStore.Min(x => x.Id).ToString();
else
lastId = CommentLstOfStore.Max(x => x.Id).ToString();
}
}
else
lastId = "-1";
IDictionary<string, string> param = new Dictionary<string, string>
{
{"storeId" , storeId.ToString()},
{"commentId" , lastId},
{"type" , type.ToString()}
};
if(lastId != "")
await SendData(typeGet, type, param);
}
/// <summary>
/// Writes the entire fiche
/// </summary>
/// <param name="_writer"></param>
/// <remarks>All chunks should have read their data and be ready to write their full content. Use the LastChanceReadBeforeWrite() to make sure your chunks (especially lazy-initialized chunks) are complete.</remarks>
public void Write(BinaryWriter _writer)
{
try {
_writer.Write(SIGNATURE);
_writer.Write(VERSION_MAJOR);
_writer.Write(VERSION_MINOR);
// Write hierarchy
_writer.Write(m_GUID.ToString());
_writer.Write(m_creationTime.ToString());
_writer.Write((uint)m_tags.Count);
foreach (Fiche parent in m_tags)
{
_writer.Write(parent.m_GUID.ToString());
}
// Write content
_writer.Write(m_type.ToString());
_writer.Write(m_title);
_writer.Write(m_URL != null);
if (m_URL != null)
{
_writer.Write(m_URL.OriginalString);
}
_writer.Write(m_HTMLContent != null);
if (m_HTMLContent != null)
{
_writer.Write(m_HTMLContent);
}
_writer.Write(m_rootElement != null);
if (m_rootElement != null)
{
m_rootElement.Write(_writer);
}
// Write chunks
_writer.Write((uint)m_chunks.Count);
foreach (ChunkBase chunk in m_chunks)
{
_writer.Write(chunk.GetType().Name);
_writer.Write((uint)0); // Placeholder => Will be filled with proper size when chunk is actually written
ulong chunkStartOffset = (ulong)_writer.BaseStream.Position;
chunk.Write(_writer);
// Go back to write chunk size
ulong chunkEndOffset = (ulong)_writer.BaseStream.Position;
uint chunkSize = (uint)(chunkEndOffset - chunkStartOffset);
_writer.BaseStream.Position = (long)(chunkStartOffset - sizeof(uint));
_writer.Write(chunkSize);
_writer.BaseStream.Position = (long)chunkEndOffset;
}
} catch (Exception _e) {
// BrainForm.Debug( "Error while saving fiche \"" + ToString() + "\": " + _e.Message );
throw _e;
}
}
// 아이템을 출현시킨다.
public GameObject RespawnItem(TYPE itemType)
{
GameObject item = null;
switch (itemType)
{
case TYPE.Lumber:
item = Lumber;
break;
case TYPE.Macintosh:
item = Macintosh;
break;
case TYPE.Corn:
item = Corn;
break;
case TYPE.Orange:
item = Orange;
break;
case TYPE.Tomato:
item = Tomato;
break;
case TYPE.Grape:
item = Grape;
break;
case TYPE.Strawberry:
item = Strawberry;
break;
default:
Debug.LogError("Invalid type: " + itemType.ToString());
return(null);
}
// 철광석 프리팹을 인스턴스화.
if (item == null)
{
Debug.LogError("item is null");
return(null);
}
GameObject go = GameObject.Instantiate(item) as GameObject;
Vector3 pos = ItemRespawn.transform.position;
// 출현 위치를 조정.
pos.y = 1.0f;
pos.x += Random.Range(-10.0f, 10.0f);
pos.z += Random.Range(-10.0f, 10.0f);
// 철광석의 위치를 이동.
go.transform.position = pos;
return(go);
}
public List <DDBinding> GetAllSuppliers(TYPE supplierType, TYPE otherType = TYPE.BOTH)
{
return(GetAll <MASTER>().Where(x => x.MASTER_VALUE.Equals(supplierType.ToString()) || x.MASTER_VALUE.Equals(otherType.ToString()))
.Join(GetAll <SUPPLIER>(), m => m.MASTER_ID, s => s.SUPPLIER_TYPE, (a, b) =>
new DDBinding
{
Id = b.SUPPLIER_ID,
Name = b.SUPPLIER_NAME
}).ToList());
}
//****************************************************************************************************
//
//****************************************************************************************************
public override HTTPReq MakeQuery_DBInsert()
{
HTTPReq query = new HTTPReq(ApplicationMain.instance.options.DBInfos.url + "/account_create.php", HTTP_METHOD.POST);
query.AddParameter("id", id.ToString(), QUERY_PARAM_TYPE.VALUE);
query.AddParameter("date_created", string.Format("{0}-{1}-{2}", m_dateCreated.Year, m_dateCreated.Month, m_dateCreated.Day), QUERY_PARAM_TYPE.VALUE);
query.AddParameter("login_username", m_loginUsername, QUERY_PARAM_TYPE.STRING);
query.AddParameter("login_password", m_loginPassword, QUERY_PARAM_TYPE.STRING);
query.AddParameter("name", name, QUERY_PARAM_TYPE.STRING);
query.AddParameter("rank", m_rank.ToString(), QUERY_PARAM_TYPE.STRING);
query.AddParameter("type", m_type.ToString(), QUERY_PARAM_TYPE.STRING);
return(query);
}
public static string GetString(this TYPE type)
{
string result = type.ToString().Replace("WingedBeast", "Winged Beast");
result = result.Replace("BeastWarrior", "Beast-Warrior");
result = result.Replace("SeaSerpent", "Sea Serpent");
result = result.Replace("DivineBeast", "Divine-Beast");
result = result.Replace("CreatorGod", "Creator God");
return(result);
}
private string itemeffect; //アイテムの説明、文字型
//ItemSpecのコンストラクタ
public ItemSpec(CLASS itemClass,
TYPE itemType,
float?numValue,
string charaValue,
string itemEffect)
{
itemclass = itemClass.ToString();
itemtype = itemType.ToString();
numvalue = numValue;
charavalue = charaValue;
itemeffect = itemEffect;
}
void updateInfo(InvenImage image, TYPE type, int count)
{
if (image == null)
{
return;
}
string infoText = string.Empty;
switch (type)
{
case TYPE.OSeed:
case TYPE.SSeed:
infoText = string.Concat(type.ToString(), "\n", count, "\nINFINITE");
image.TextItemInfo.text = infoText;
break;
case TYPE.Lumber:
case TYPE.Macintosh:
case TYPE.Corn:
case TYPE.Tomato:
case TYPE.Grape:
case TYPE.MSeed:
case TYPE.CSeed:
case TYPE.Orange:
case TYPE.Strawberry:
case TYPE.TSeed:
case TYPE.GSeed:
infoText = string.Concat(type.ToString(), "\n", count);
image.TextItemInfo.text = infoText;
break;
}
if (string.IsNullOrEmpty(infoText))
{
Debug.LogError("invalid type: " + type.ToString());
}
}
public void ReplaceContained(CONTAINED newContained, int state)
{
Destroy(this.transform.Find(contained.ToString()).gameObject);
contained = newContained;
containedObject = Instantiate(contained.GetPrefab(), transform.position, Quaternion.identity, this.transform) as GameObject;
containedObject.name = newContained.ToString();
behaviour = containedObject.GetComponent <IBehaviour>();
behaviour.Initialize(state);
behaviour.SetSprite(tileset);
this.name = contained.ContainsNone() ? type.ToString() : contained.ToString();
}
public File(string config_value)
{
string[] values = config_value.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if ((values.Length == 2) &&
(Enum.IsDefined(typeof(TYPE), values[1].ToUpperInvariant()) == true))
{
Type = (TYPE)Enum.Parse(typeof(TYPE), values[1].ToUpperInvariant());
Name = string.Format("{0}.{1}", values[0], Type.ToString().ToLowerInvariant());
}
else
{
;
}
}
public override void WriteCSVLine(StreamWriter sw)
{
sw.Write(CTR);
sw.Write(";");
sw.Write(VFROM.Year.ToString() + "/" + VFROM.Month.ToString() + "/" + VFROM.Day.ToString());
sw.Write(";");
sw.Write(VTO.Year.ToString() + "/" + VTO.Month.ToString() + "/" + VTO.Day.ToString());
sw.Write(";");
sw.Write(TYPE.ToString());
sw.Write(";");
sw.Write(PROFCTR);
sw.Write(";");
sw.Write("");
sw.Write(";");
sw.WriteLine(GEOCODE);
}
public void AddDevice()
{
TYPE type = UserTypeSelector();
string ID = AskID();
string name = AskName();
DateTime warranty = AskDateTime();
double price = AskPrice();
CreateDevice createGivenDevice = CreateCustomDeviceDelegate(type);
Devices.Add(createGivenDevice(type, ID, name, warranty, price));
Console.Clear();
Console.WriteLine("New {0} was successfully added!", type.ToString().ToLower());
Thread.Sleep(2000);
}
virtual public JSONObject GetFileData()
{
Dictionary <string, string> data = new Dictionary <string, string> {
{ "id", _id }, { "layer_type", _type.ToString() }, { "ingroup", _inputGroup.Id }, { "outgroup", _outputGroup.Id }
};
JSONObject result = new JSONObject(data);
Dictionary <string, JSONObject> groups = new Dictionary <string, JSONObject>();
foreach (NeuralGroup g in _groups.Values)
{
groups[g.Id] = g.GetFileData();
}
result.AddField("groups", new JSONObject(groups));
return(result);
}
void Internal.IResponseReader.ReadResponse(Internal.ByteReader reader)
{
NAME = reader.ReadDomain();
// TYPE may be not understood
TypeValue = reader.ReadUIn16();
if (Enum.IsDefined(typeof(QTYPE), TypeValue))
{
// known type
TYPE = (QTYPE)TypeValue;
TypeString = TYPE.ToString();
}
else
{
// unknown type
TYPE = null;
TypeString = String.Format("[{0}]", TypeValue.ToString());
}
CLASS = reader.ReadUIn16Enum <QCLASS>();
TTL = reader.ReadUint32();
RDLENGTH = reader.ReadUIn16();
}
public File(string config_value)
{
string[] values = config_value.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (values.Length == 2)
{
if (Enum.IsDefined(typeof(TYPE), values[1].ToUpperInvariant()) == true)
{
Type = (TYPE)Enum.Parse(typeof(TYPE), values[1].ToUpperInvariant());
NameWithoutExt = string.Format("{0}", values[0]);
Name = string.Format("{0}.{1}", NameWithoutExt, Type.ToString().ToLowerInvariant());
}
else
{
// неизвестный тип
;
}
}
else
{
// наименование файла указано по неизвестному правилу
;
}
}
public async void LoadMoreMarket(string name, TYPEGET type, TYPE isOld = 0)
{
string lastId = "";
if (type == TYPEGET.MORE)
{
if (MarketItemList.Count != 0)
{
if (isOld == TYPE.OLD)
lastId = MarketItemList.Min(x => x.MarketId).ToString();
else
lastId = MarketItemList.Max(x => x.MarketId).ToString();
}
}
else
lastId = "-1";
IDictionary<string, string> param = new Dictionary<string, string>
{
{"id" , lastId},
{"name" , name},
{"type" , isOld.ToString()}
};
if(lastId != "")
await SendData(type, isOld, param);
}
public async void LoadMoreProduct(TYPEGET type, TYPE isOld=0)
{
string lastId = "-1";
if (type == TYPEGET.MORE)
{
if (ProductList.Count != 0)
{
if (isOld == TYPE.OLD)
lastId = ProductList.Min(x => x.ProductId).ToString();
else
lastId = ProductList.Max(x => x.ProductId).ToString();
}
}
IDictionary<string, string> param = new Dictionary<string, string>
{
{"id" , lastId},
{"type" , isOld.ToString()}
};
await SendData(type, isOld, param);
}
public void PrintElement(ref string str, int level)
{
str += "------------------------------------------------------------------------------------------\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "ID: " + id + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "Name Orig: " + nameOrig + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "Name: " + name + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "NameLower: " + nameLower + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "Type: " + type.ToString() + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "Variable: " + variableName + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "Variable_obj: " + variableName_obj + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "className: " + className + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "classInstanceName: " + classInstanceName + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "classListenerFunction: " + classButtonListenerFunction + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
str += "classToggleListenerFunction: " + classToggleListenerFunction + "\n";
for (int i = 0; i < level; ++i)
{
str += ("\t");
}
try {
str += "Parent: " + parent.variableName + "\n";
}
catch { }
for (int i = 0; i < this.children.Count; ++i)
{
this.children[i].PrintElement(ref str, level + 1);
}
}
private static int SizeOf(TYPE type)
{
switch (type)
{
case TYPE.BYTE:
case TYPE.INT8:
case TYPE.UINT8:
case TYPE.CHAR:
case TYPE.BOOL:
return(1);
case TYPE.INT16:
case TYPE.UINT16:
return(2);
case TYPE.INT32:
case TYPE.UINT32:
return(4);
case TYPE.INT64:
case TYPE.UINT64:
return(8);
case TYPE.STRUCT:
return(0);
}
throw new System.Exception(String.Format("STRUCT::SizeOf - Unexpected type: {0}", type.ToString()));
}
public async void LoadMoreSale(string title, TYPEGET type, TYPE isOld=0)
{
string lastId = "";
if (type == TYPEGET.MORE)
{
if (SaleList.Count != 0)
{
if (isOld == TYPE.OLD)
lastId = SaleList.Min(x => x.SaleId).ToString();
else
lastId = SaleList.Max(x => x.SaleId).ToString();
}
}
else
lastId = "-1";
IDictionary<string, string> param = new Dictionary<string, string>
{
{"id" , lastId},
{"title" , title},
{"type" , isOld.ToString()}
};
if(lastId != "")
await SendData(type, isOld, param);
}
public async void GetProductsOfStore(TYPEGET typeGet, TYPE type=0)
{
string lastId = "-1";
int storeId = MediateClass.KiotVM.SelectedStore.StoreId;
if (typeGet == TYPEGET.MORE)
{
if (ProductsOfStore.Count != 0)
{
if (type == TYPE.OLD)
lastId = ProductsOfStore.Min(x => x.ProductId).ToString();
else
lastId = ProductsOfStore.Max(x => x.ProductId).ToString();
}
}
IDictionary<string, string> param = new Dictionary<string, string>
{
{"storeId" , storeId.ToString()},
{"productId" , lastId},
{"type" , type.ToString()}
};
if(lastId != "")
await PassDataOfStore(typeGet, type, param);
}
protected string BuildMessage(TYPE type, string message)
{
string msg = null;
#region Filter By Level
switch (level)
{
case LEVEL.ALL:
msg = message;
break;
case LEVEL.ONLY_INFO:
if (type == TYPE.INFO)
{
msg = message;
}
break;
case LEVEL.ONLY_PROMPT:
if (type == TYPE.PROMPT)
{
msg = message;
}
break;
case LEVEL.ONLY_WARNING:
if (type == TYPE.WARNING)
{
msg = message;
}
break;
case LEVEL.ONLY_ERROR:
if (type == TYPE.ERROR)
{
msg = message;
}
break;
case LEVEL.INFO_PROMPT:
if (type == TYPE.INFO)
{
msg = message;
}
if (type == TYPE.PROMPT)
{
msg = message;
}
break;
case LEVEL.INFO_WARNING:
if (type == TYPE.INFO)
{
msg = message;
}
if (type == TYPE.WARNING)
{
msg = message;
}
break;
case LEVEL.INFO_ERROR:
if (type == TYPE.INFO)
{
msg = message;
}
if (type == TYPE.ERROR)
{
msg = message;
}
break;
case LEVEL.PROMPT_WARNING:
if (type == TYPE.PROMPT)
{
msg = message;
}
if (type == TYPE.WARNING)
{
msg = message;
}
break;
case LEVEL.PROMPT_ERROR:
if (type == TYPE.PROMPT)
{
msg = message;
}
if (type == TYPE.ERROR)
{
msg = message;
}
break;
case LEVEL.WARNING_ERROR:
if (type == TYPE.WARNING)
{
msg = message;
}
if (type == TYPE.ERROR)
{
msg = message;
}
break;
case LEVEL.INFO_PROMPT_WARNING:
if (type == TYPE.INFO)
{
msg = message;
}
if (type == TYPE.PROMPT)
{
msg = message;
}
if (type == TYPE.WARNING)
{
msg = message;
}
break;
case LEVEL.PROMPT_WARNING_ERROR:
if (type == TYPE.PROMPT)
{
msg = message;
}
if (type == TYPE.WARNING)
{
msg = message;
}
if (type == TYPE.ERROR)
{
msg = message;
}
break;
}
#endregion
if (msg == null)
{
return(null);
}
var now = DateTime.Now;
var time = string.Format("{0} {1}:{2}:{3}({4})",
now.ToString(date),
now.Hour.ToString().PadLeft(2, '0'), now.Minute.ToString().PadLeft(2, '0'), now.Second.ToString().PadLeft(2, '0'),
now.Millisecond.ToString().PadLeft(3, '0'));
msg = string.Format(pattern, time, id, type.ToString().First(), msg);
return(msg);
}
public virtual void Write(TYPE value)
{
Write(value.ToString());
}
public async void GetNewProductList(TYPEGET typeGet, TYPE type = TYPE.OLD)
{
try
{
JArray result = new JArray();
int lastId = -1;
if (typeGet == TYPEGET.MORE)
{
if (NewProductList.Count != 0)
{
if (type == TYPE.OLD)
lastId = NewProductList.Min(x => x.ProductId);
else
lastId = NewProductList.Max(x => x.ProductId);
}
}
IDictionary<string, string> param = new Dictionary<string, string>
{
{"typeProduct" , type.ToString()},
{"productId" , lastId.ToString()}
};
if (Utilities.Helpers.NetworkHelper.Instance.HasInternetConnection)
{
if (!isResponse)
{
isResponse = true;
var response = await App.MobileService.InvokeApiAsync("ProductStatistics", HttpMethod.Get, param);
result = JArray.Parse(response.ToString());
ObservableCollection<Product> more = result.ToObject<ObservableCollection<Product>>();
if (typeGet == TYPEGET.START)
{
NewProductList = more;
}
else
{
if (type == TYPE.OLD)
{
foreach (var item in more)
{
NewProductList.Add(item);
}
}
else
{
for (int i = 0; i < more.Count; i++)
{
NewProductList.Insert(i, more[i]);
}
}
}
}
}
}
catch (Exception ex)
{
await new MessageDialog(ex.Message.ToString(), "Load Product").ShowAsync();
}
finally
{
isResponse = false;
}
}
public static void Write(TYPE value)
{
Out.Write(value.ToString());
}
private Exception MyException(EX_TYPE ex, string op, object parm = null, object info = null)
{
String msg = "";
switch (ex)
{
case EX_TYPE.INVALID_OPERATION:
msg = "Invalid operation";
break;
case EX_TYPE.INVALID_TYPE:
msg = "Invalid type";
break;
case EX_TYPE.OUT_OF_INDEX:
msg = String.Format("Out of index, size: {0}", count);
break;
case EX_TYPE.CONVERSION_FAILED:
msg = String.Format("Conversion failed {0}", info);
break;
default:
msg = string.Format("Unknown exception {0}", ex.ToString());
break;
}
String header = String.Format("STRUCT:: {0}[{1}].{2}({3}) - ", this.name, type.ToString(), op, parm);
return(new Exception(string.Format("STRUCT:: {0}[{1}].{2}({3}) - {4}", this.name, type.ToString(), op, parm, msg)));
}
public async void LoadMoreStore(TYPEGET typeGet,TYPE type=0)
{
string lastId = "";
int marketId = MediateClass.MarketVM.SelectedMarket.MarketId;
if (typeGet == TYPEGET.MORE)
{
if (KiosList.Count != 0)
{
if (type == TYPE.OLD)
lastId = KiosList.Min(x => x.StoreId).ToString();
else
lastId = KiosList.Max(x => x.StoreId).ToString();
}
}
else
lastId = "-1";
IDictionary<string, string> param = new Dictionary<string, string>
{
{"marketId", marketId.ToString()},
{"storeId" , lastId},
{"type" , type.ToString()}
};
if(lastId != "")
await SendData(typeGet, type, param);
}
public string ToSaveString()
{
string strType = (m_type == TYPE.LIST) ? "TEXT" : m_type.ToString();
return(m_strName + "; " + m_objValue.ToString() + "; " + strType + "; " + m_strExtra);
}
public void SetUpTile(TYPE typeSetUp, CONTAINED containedSetup, int state, int room_tileset, int[] position)
{
foreach (Transform child in transform)
{
GameObject.Destroy(child.gameObject);
}
typeObject = Instantiate(Resources.Load("Prefabs/Type"), transform.position, Quaternion.identity, this.transform) as GameObject;
typeObject.name = "Type";
this.position = position;
Transform typeSprite = typeObject.transform;
type = typeSetUp;
contained = containedSetup;
canPass = true;
reserved = false;
tileset = room_tileset;
switch (typeSetUp)
{
case TYPE.floor:
fireObject = Instantiate(Resources.Load("Prefabs/Fire"), transform.position, Quaternion.identity, this.transform) as GameObject;
fireScript = fireObject.GetComponent <Fire>();
fireObject.name = "Fire";
room_images = getRoomImages(room_tileset, floor_images);
typeSprite.GetComponent <SpriteRenderer>().sprite = room_images[Random.Range(0, room_images.Length - 1)];
break;
case TYPE.wall:
typeSprite.GetComponent <SpriteRenderer>().sprite = wall_images[Random.Range(0, wall_images.Length - 1)];
canPass = false;
break;
case TYPE.front_wall:
room_images = getRoomImages(room_tileset, front_wall_images);
typeSprite.GetComponent <SpriteRenderer>().sprite = room_images[Random.Range(0, room_images.Length - 1)];
canPass = false;
break;
case TYPE.breakable_wall:
//room_images = getRoomImages(room_tileset, breakable_wall_images);
canPass = false;
break;
case TYPE.stair_up:
Sprite orientation;
if (position[1] == 1)
{
orientation = stair_up_bottom_image;
}
else if (position[1] >= GameManager.instance.GetComponent <LevelGenerator>().columns - 3)
{
orientation = stair_up_top_image;
}
else if (position[0] == (GameManager.instance.level - 1) * GameManager.instance.boardScript.rows + 1)
{
orientation = stair_up_left_image;
}
else
{
orientation = stair_up_right_image;
}
typeSprite.GetComponent <SpriteRenderer>().sprite = orientation;
break;
case TYPE.stair_down:
Sprite orientationD;
if (position[1] == 1)
{
orientationD = stair_down_bottom_image;
}
else if (position[1] >= GameManager.instance.GetComponent <LevelGenerator>().columns - 3)
{
orientationD = stair_down_top_image;
}
else if (position[0] == (GameManager.instance.level - 1) * GameManager.instance.boardScript.rows + 1)
{
orientationD = stair_down_left_image;
}
else
{
orientationD = stair_down_right_image;
}
typeSprite.GetComponent <SpriteRenderer>().sprite = orientationD;
break;
default:
Debug.Log("Tile type " + typeSetUp + " entered default state (Floor)");
type = typeSetUp;
break;
}
CheckTileIntegrity();
containedObject = Instantiate(contained.GetPrefab(), transform.position, Quaternion.identity, this.transform) as GameObject;
containedObject.name = containedSetup.ToString();
behaviour = containedObject.GetComponent <IBehaviour>();
behaviour.Initialize(state);
behaviour.SetSprite(room_tileset);
this.name = contained.ContainsNone() ? type.ToString() : contained.ToString();
}
public List <T> GetDetails <T>(Func <T, int> joinOn, string invoiceNo, string invoiceDate, TYPE purchaseType) where T : class
{
return(GetAll <INVOICE>(s => s.PURCHASE_TYPE == GetMasterId(purchaseType.ToString()))
.Join(GetAll <T>(), i => i.INVOICE_ID, joinOn, (a, b) => new { a, b }).Where(s => s.a.INVOICE_NO.Equals(invoiceNo) && s.a.INVOICE_DATE.Equals(Convert.ToDateTime(invoiceDate)))
.Select(s => s.b).ToList());
}