public static BaseEnum GetTileEnumFromName(string tileName)
{
BaseEnum baseEnumValue = BaseEnum.HOME_BASE;
if (tileName.Equals(NameConstants.HOME_BASE_NAME))
{
baseEnumValue = BaseEnum.HOME_BASE;
}
else if (tileName.Equals(NameConstants.FIRST_BASE_NAME))
{
baseEnumValue = BaseEnum.FIRST_BASE;
}
else if (tileName.Equals(NameConstants.SECOND_BASE_NAME))
{
baseEnumValue = BaseEnum.SECOND_BASE;
}
else if (tileName.Equals(NameConstants.THIRD_BASE_NAME))
{
baseEnumValue = BaseEnum.THIRD_BASE;
}
else if (tileName.Equals(NameConstants.PITCHER_BASE_NAME))
{
baseEnumValue = BaseEnum.PITCHER_BASE;
}
return(baseEnumValue);
}
private Vector3 GetNextBasePosition(BaseEnum currentBase)
{
Vector3 nextPosition = new Vector3();
switch (currentBase)
{
case BaseEnum.HOME_BASE:
Debug.Log("GO FROM HOME BASE TO FIRST BASE !!");
nextPosition = FieldUtils.GetTileCenterPositionInGameWorld(FieldUtils.GetFirstBaseTilePosition());
break;
case BaseEnum.FIRST_BASE:
Debug.Log("GO FROM FIRST BASE TO SECOND BASE !!");
nextPosition = FieldUtils.GetTileCenterPositionInGameWorld(FieldUtils.GetSecondBaseTilePosition());
break;
case BaseEnum.SECOND_BASE:
Debug.Log("GO FROM SECOND BASE TO THIRD BASE !!");
nextPosition = FieldUtils.GetTileCenterPositionInGameWorld(FieldUtils.GetThirdBaseTilePosition());
break;
case BaseEnum.THIRD_BASE:
Debug.Log("GO FROM THIRD BASE TO HOME BASE !!");
nextPosition = FieldUtils.GetTileCenterPositionInGameWorld(FieldUtils.GetHomeBaseTilePosition());
break;
default:
Debug.Log("DO NOT KNOW WHAT HAPPEN");
break;
}
return(nextPosition);
}
public void GoToNextBase(BaseEnum currentBase, bool isAutomaticCommand = false)
{
Debug.Log(this.name + " go to next base");
this.IsStaying = false;
PlayersTurnManager playersTurnManager = GameUtils.FetchPlayersTurnManager();
playersTurnManager.UpdatePlayerTurnAvailability(this.gameObject.name, TurnAvailabilityEnum.WAITING);
Vector3 nextPosition = this.GetNextBasePosition(currentBase);
this.Target = nextPosition;
this.EnableMovement = true;
GameManager gameManager = GameUtils.FetchGameManager();
if (!isAutomaticCommand)
{
Debug.Log(this.name + " proceed manually");
this.CalculateNextAction();
}
else if (isAutomaticCommand && gameManager.AttackTeamRunnerList.Count > 1)
{
if (this.gameObject.Equals(playersTurnManager.GetNextRunnerTakingAction()))
{
playersTurnManager.IsSkipNextRunnerTurnEnabled = true;
}
Debug.Log(this.name + " proceed automaticaly");
playersTurnManager.TurnState = TurnStateEnum.RUNNER_TURN;
PlayersTurnManager.IsCommandPhase = true;
}
}
/// <summary>
/// 写日志
/// </summary>
private static void WriteLog(BaseEnum mtype)
{
var fileName = GetLogFileName(mtype);
var IsWriteToLog = File.Exists(fileName);
if (!IsWriteToLog)
{
try
{
//须close掉，不然无法写入
File.Create(fileName).Close();
IsWriteToLog = true;
}
catch (Exception e)
{
IsWriteToLog = false;
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog", e.Message));
}
}
if (IsWriteToLog)
{
WriteLog2(mtype, fileName);
}
}
/// <summary>
/// 播放动画Clip
/// </summary>
/// <param name="stateName">要播放的Clip名称</param>
/// <param name="flag">true:播放 false:停止</param>
private void PlayAnimator(BaseEnum.PlayerState stateName)//, bool flag = true
{
if (stateName == GetState()) return;
string name = GetName(typeof(BaseEnum.PlayerState), stateName);
m_PlayerAnim.SetTrigger(name);
}
public PageResult GetMergePayInfoList(QueryMergePayInfo model)
{
int count = 0;
if (model.page == 0)
{
model.page = 1;
}
if (model.limit == 0)
{
model.limit = 10;
}
var where = PredicateBuilder.True <MergePayInfo>();
if (!string.IsNullOrEmpty(model.Name))
{
where = where.And(s => s.Name == model.Name);
}
if (!string.IsNullOrEmpty(model.IdentityCardNo))
{
where = where.And(s => s.IdentityCardNo == model.IdentityCardNo);
}
if (model.StatusList != null && model.StatusList.Any())
{
where = where.And(s => model.StatusList.Contains(s.Status));
}
var list = GetListByPage <MergePayInfo, DateTime>(ref count, model.page, model.limit, where, by => by.AddTime, true).ToList();
List <MergeResponseDTO> retlist = new List <MergeResponseDTO>();
foreach (var m in list)
{
MergeResponseDTO merge = new MergeResponseDTO
{
MergeId = m.MergeId,
MerchantNo = m.MerchantNo,
UserId = m.UserId,
OrderCount = m.OrderCount,
Amount = m.Amount,
Name = m.Name,
BankCardNo = m.BankCardNo,
IdentityCardNo = m.IdentityCardNo,
BankName = m.BankName,
IdentityType = BaseEnum.GetEnumDescription(typeof(IdentityTypeEnum), m.IdentityType),
PayDate = m.PayDate == null?"":m.PayDate.ToString(),
RepulseRemark = m.RepulseRemark,
ImgPath = m.ImgPath,
UpdateTime = m.UpdateTime == null?"":m.UpdateTime.ToString(),
AddTime = m.AddTime,
Status = BaseEnum.GetEnumDescription(typeof(MergeStatusEnum), m.Status)
};
retlist.Add(merge);
}
return(new PageResult()
{
data = retlist, count = count
});
}
/// <summary>
/// 获取日志文件名称
/// </summary>
private static string GetLogFileName(BaseEnum mtype)
{
var fileName = "";
var logFileDir = "";
switch (mtype)
{
case BaseEnum.Adobe:
logFileDir = LogDir_Adobe;
break;
case BaseEnum.Collect:
logFileDir = LogDir_Collect;
break;
case BaseEnum.Main:
logFileDir = LogDir_Main;
break;
case BaseEnum.Msg:
logFileDir = LogDir_Msg;
break;
case BaseEnum.Socket:
logFileDir = LogDir_Socket;
break;
case BaseEnum.NQ:
logFileDir = LogDir_NQ;
break;
default:
break;
}
if (!Directory.Exists(logFileDir))
{
try
{
//创建路径
Directory.CreateDirectory(logFileDir);
MangeFiles(logFileDir);
}
catch (Exception e)
{
fileName = null;
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "GetLogFileName", e.Message));
return(null);
}
}
fileName = Application.StartupPath + "\\" + logFileDir + "\\" + DateTime.Now.ToString("yyyy-MM-dd") + ".log";
return(fileName);
}
/// <summary>
/// 异常处理
/// </summary>
public static void ExceptionDeal(BaseEnum baseEnum, string msg)
{
switch (baseEnum)
{
case BaseEnum.Adobe:
lock (lstLogs_Adobe)
{
lstLogs_Adobe.Add(msg);
}
break;
case BaseEnum.Collect:
lock (lstLogs_Collect)
{
lstLogs_Collect.Add(msg);
}
break;
case BaseEnum.Main:
lock (lstLogs_Main)
{
lstLogs_Main.Add(msg);
}
break;
case BaseEnum.Msg:
lock (lstLogs_Msg)
{
lstLogs_Msg.Add(msg);
}
break;
case BaseEnum.Socket:
lock (lstLogs_Socket)
{
lstLogs_Socket.Add(msg);
}
break;
case BaseEnum.NQ:
lock (lstLogs_NQ)
{
lstLogs_NQ.Add(msg);
}
break;
default:
break;
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = EnumTypeFullyQualified.GetHashCode();
hashCode = (hashCode * 397) ^ IsValidatable.GetHashCode();
hashCode = (hashCode * 397) ^ HasCreateInvalidImplementation.GetHashCode();
hashCode = (hashCode * 397) ^ IsReferenceType.GetHashCode();
hashCode = (hashCode * 397) ^ IsAbstract.GetHashCode();
hashCode = (hashCode * 397) ^ AttributeInfo.GetHashCode();
hashCode = (hashCode * 397) ^ KeyProperty.GetHashCode();
hashCode = (hashCode * 397) ^ (BaseEnum?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ Settings.GetHashCode();
hashCode = (hashCode * 397) ^ ItemNames.ComputeHashCode();
hashCode = (hashCode * 397) ^ AssignableInstanceFieldsAndProperties.ComputeHashCode();
hashCode = (hashCode * 397) ^ FullyQualifiedDerivedTypes.ComputeHashCode();
return(hashCode);
}
}
public static BaseEnum RetrieveBaseEnum(this ApiController apiController, HttpRequestMessage request, Guid id, Database database)
{
var getBaseEnum = new GetObject <BaseEnum>();
BaseEnum baseEnum = getBaseEnum.Execute(id);
if (baseEnum == null)
{
var response = request.CreateErrorResponse(HttpStatusCode.NotFound, String.Format("Base enum with id '{0}' does not exist", id));
throw new HttpResponseException(response);
}
if (baseEnum.DatabaseId != database.Id)
{
var response = request.CreateErrorResponse(
HttpStatusCode.BadRequest,
String.Format("Base enum with id '{0}' does not belong to the database with id '{1}'", baseEnum.Id, database.Id));
throw new HttpResponseException(response);
}
return(baseEnum);
}
// GET: TableDeMultiplication
public ActionResult TableMultiplication(int matrix_size = 10, BaseEnum matrix_base = BaseEnum.Decimale)
{
TableDeMultiplication model = _matrixMultiplicationFactory.buildMatrixMultiplication(matrix_size, matrix_base);
return(View(model));
}
private static extern int OodleLZ_Compress(OodleFormat format, byte[] decompressedBuffer, long decompressedSize,
byte[] compressedBuffer, OodleCompressionLevel compressionLevel, uint uint0, uint uint1, uint uint2,
BaseEnum genum);
private static void WriteLog2(BaseEnum mtype, string fileName)
{
lock (lockerLog)
{
var file = new FileInfo(fileName);
if (file.Exists)
{
if (file.Length > 30 * 1024 * 1024)
{
file.Delete();
}
}
var sw = new StreamWriter(fileName, true);
switch (mtype)
{
case BaseEnum.Adobe:
#region MyRegion
lock (lstLogs_Adobe)
{
foreach (var item in lstLogs_Adobe)
{
try
{
sw.WriteLine(item);
}
catch (Exception e)
{
ExceptionDeal(mtype,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog2", e.Message));
}
}
lstLogs_Adobe.Clear();
}
#endregion
break;
case BaseEnum.Collect:
#region MyRegion
lock (lstLogs_Collect)
{
foreach (var item in lstLogs_Collect)
{
try
{
sw.WriteLine(item);
}
catch (Exception e)
{
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog2", e.Message));
}
}
lstLogs_Collect.Clear();
}
break;
#endregion
case BaseEnum.Main:
#region MyRegion
lock (lstLogs_Main)
{
foreach (var item in lstLogs_Main)
{
try
{
sw.WriteLine(item);
}
catch (Exception e)
{
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog2", e.Message));
}
}
lstLogs_Main.Clear();
}
#endregion
break;
case BaseEnum.Msg:
#region MyRegion
lock (lstLogs_Msg)
{
foreach (var item in lstLogs_Msg)
{
try
{
sw.WriteLine(item);
}
catch (Exception e)
{
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog2", e.Message));
}
}
lstLogs_Msg.Clear();
}
#endregion
break;
case BaseEnum.Socket:
#region MyRegion
lock (lstLogs_Socket)
{
foreach (var item in lstLogs_Socket)
{
try
{
sw.WriteLine(item);
}
catch (Exception e)
{
ExceptionDeal(BaseEnum.Main,
string.Format("{0} {1} {2}", DateTime.Now.ToString(strTimeFormat),
mtype + "." + "WriteLog2", e.Message));
}
}
lstLogs_Socket.Clear();
}
#endregion
break;
default:
break;
}
sw.Close();
sw.Dispose();
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
PlayerStatus playerStatusScript = PlayerUtils.FetchPlayerStatusScript(this.gameObject);
GenericPlayerBehaviour genericPlayerBehaviourScript = PlayerUtils.FetchCorrespondingPlayerBehaviourScript(this.gameObject, playerStatusScript);
if (ColliderUtils.HasBallCollided(collision.collider))
{
GameObject ballGameObject = collision.collider.gameObject;
BallController ballControllerScript = BallUtils.FetchBallControllerScript(ballGameObject);
if (PlayerUtils.HasCatcherPosition(this.gameObject) && ballControllerScript.CurrentPasser != this.gameObject)
{
CatcherBehaviour catcherBehaviour = (CatcherBehaviour)genericPlayerBehaviourScript;
if (catcherBehaviour.CatcherMode == ModeConstants.CATCHER_FIELDER_MODE)
{
PlayerActionsManager.InterceptBall(ballGameObject, ballControllerScript, genericPlayerBehaviourScript);
catcherBehaviour.CatcherMode = ModeConstants.CATCHER_NORMAL_MODE;
this.gameObject.transform.position = FieldUtils.GetTileCenterPositionInGameWorld(FieldUtils.GetCatcherZonePosition());
catcherBehaviour.IsoRenderer.ReinitializeAnimator();
}
PlayersTurnManager playersTurnManager = GameUtils.FetchPlayersTurnManager();
playersTurnManager.TurnState = TurnStateEnum.CATCHER_TURN;
PlayersTurnManager.IsCommandPhase = true;
}
else if (PlayerUtils.HasFielderPosition(this.gameObject) && !ballControllerScript.IsPitched && ballControllerScript.CurrentPasser != this.gameObject)
{
((FielderBehaviour)genericPlayerBehaviourScript).CalculateFielderColliderInterraction(ballGameObject, ballControllerScript, genericPlayerBehaviourScript);
}
else if (PlayerUtils.HasPitcherPosition(this.gameObject) && !ballControllerScript.IsPitched && !ballControllerScript.IsPassed && ballControllerScript.CurrentPasser != this.gameObject)
{
((PitcherBehaviour)genericPlayerBehaviourScript).CalculatePitcherColliderInterraction(ballGameObject, ballControllerScript, genericPlayerBehaviourScript);
}
}
else if (ColliderUtils.HasPlayerCollided(collision))
{
if (PlayerUtils.HasFielderPosition(this.gameObject) && genericPlayerBehaviourScript.IsHoldingBall && PlayerUtils.HasRunnerPosition(collision.gameObject))
{
PlayerStatus runnerToTagOutStatus = PlayerUtils.FetchPlayerStatusScript(collision.transform.gameObject);
RunnerBehaviour runnerBehaviourScript = ((RunnerBehaviour)PlayerUtils.FetchCorrespondingPlayerBehaviourScript(collision.transform.gameObject, runnerToTagOutStatus));
if (!runnerBehaviourScript.IsSafe)
{
((FielderBehaviour)genericPlayerBehaviourScript).TagOutRunner(collision.transform.gameObject);
}
else
{
((FielderBehaviour)genericPlayerBehaviourScript).ReplanAction();
}
}
}
else
{
if (PlayerUtils.HasRunnerPosition(this.gameObject))
{
if (!ColliderUtils.IsBaseTile(collision.gameObject.name))
{
return;
}
if (genericPlayerBehaviourScript == null)
{
return;
}
if (!genericPlayerBehaviourScript.IsPrepared)
{
return;
}
RunnerBehaviour runnerBehaviour = ((RunnerBehaviour)genericPlayerBehaviourScript);
BaseEnum baseReached = runnerBehaviour.NextBase;
if (baseReached == BaseEnum.HOME_BASE && runnerBehaviour.HasPassedThroughThreeFirstBases())
{
//win a point automaticaly without issuing commands if arrived at home base after a complete turn
runnerBehaviour.CalculateRunnerColliderInterraction(FieldUtils.GetTileEnumFromName(collision.gameObject.name), true);
}
else if (baseReached == BaseEnum.FIRST_BASE && runnerBehaviour.IsInWalkState)
{
//Walk done after 4 ball from pitcher
runnerBehaviour.CalculateRunnerColliderInterraction(FieldUtils.GetTileEnumFromName(collision.gameObject.name));
PlayersTurnManager playersTurnManager = GameUtils.FetchPlayersTurnManager();
playersTurnManager.TurnState = TurnStateEnum.PITCHER_TURN;
PlayersTurnManager.IsCommandPhase = true;
}
else if (baseReached == BaseEnum.HOME_BASE)
{
//automaticaly run to next base, no need for command input
runnerBehaviour.CalculateRunnerColliderInterraction(FieldUtils.GetTileEnumFromName(collision.gameObject.name));
runnerBehaviour.GoToNextBase(baseReached, true);
}
else
{
//Runner next turn
runnerBehaviour.CalculateRunnerColliderInterraction(FieldUtils.GetTileEnumFromName(collision.gameObject.name), true);
}
}
}
}
public void CalculateRunnerColliderInterraction(BaseEnum baseReached, bool isNextRunnerTurnPossible = false)
{
Debug.Log(this.name + " interracted with " + baseReached.ToString());
this.CurrentBase = baseReached;
PlayerStatus playerStatusScript = PlayerUtils.FetchPlayerStatusScript(this.gameObject);
this.EnableMovement = false;
PlayersTurnManager playersTurnManager = GameUtils.FetchPlayersTurnManager();
TurnAvailabilityEnum turnAvailabilityEnum = TurnAvailabilityEnum.READY;
switch (baseReached)
{
case BaseEnum.HOME_BASE:
if (baseReached == BaseEnum.HOME_BASE && !this.HasPassedThroughThreeFirstBases())
{
Debug.Log("Get on HOME BASE FIRST TIME !!");
this.NextBase = BaseEnum.FIRST_BASE;
playersTurnManager.TurnState = TurnStateEnum.STANDBY;
playersTurnManager.UpdatePlayerTurnAvailability(this.gameObject.name, turnAvailabilityEnum);
}
else
{
Debug.Log("Get on HOME BASE to mark a point");
Debug.Log("WIN ONE POINT !!!");
this.Target = null;
this.NextBase = this.CurrentBase;
playerStatusScript.IsAllowedToMove = false;
this.HasReachedHomeBase = true;
PlayerEnum playerEnum = playerStatusScript.PlayerOwner;
TeamsScoreManager teamsScoreManagerScript = GameUtils.FetchTeamsScoreManager();
teamsScoreManagerScript.IncrementTeamScore(GameData.teamIdEnumMap[playerEnum]);
this.IsStaying = true;
IsoRenderer.ReinitializeAnimator();
GameManager gameManager = GameUtils.FetchGameManager();
this.gameObject.SetActive(false);
gameManager.AttackTeamRunnerList.Remove(this.gameObject);
playersTurnManager.UpdatePlayerTurnQueue(this.gameObject);
gameManager.AttackTeamRunnerHomeList.Add(this.gameObject);
int batterCount = gameManager.AttackTeamBatterListClone.Count;
if (this.EquipedBat != null && batterCount > 0)
{
GameObject newBatter = gameManager.AttackTeamBatterListClone.First();
BatterBehaviour newbatterBehaviourScript = PlayerUtils.FetchBatterBehaviourScript(newBatter);
newbatterBehaviourScript.EquipedBat = this.EquipedBat;
this.EquipedBat = null;
gameManager.EquipBatToPlayer(newBatter);
}
int runnersCount = gameManager.AttackTeamRunnerList.Count;
bool isRunnersAllSafeAndStaying = gameManager.AttackTeamRunnerList.TrueForAll(runner => {
RunnerBehaviour runnerBehaviour = PlayerUtils.FetchRunnerBehaviourScript(runner);
return(runnerBehaviour.IsSafe && runnerBehaviour.IsStaying);
});
if (runnersCount == 0 && batterCount == 0 || batterCount == 0 && runnersCount > 0 && isRunnersAllSafeAndStaying)
{
gameManager.IsStateCheckAllowed = false;
gameManager.ProcessNextInningHalf();
}
else
{
gameManager.IsStateCheckAllowed = true;
}
}
break;
case BaseEnum.FIRST_BASE:
Debug.Log("Get on FIRST BASE");
this.NextBase = BaseEnum.SECOND_BASE;
this.HasReachedFirstBase = true;
if (this.IsInWalkState)
{
this.IsInWalkState = false;
turnAvailabilityEnum = TurnAvailabilityEnum.WAITING;
IsoRenderer.ReinitializeAnimator();
}
playersTurnManager.UpdatePlayerTurnAvailability(this.gameObject.name, turnAvailabilityEnum);
break;
case BaseEnum.SECOND_BASE:
Debug.Log("Get on SECOND BASE");
this.NextBase = BaseEnum.THIRD_BASE;
this.HasReachedSecondBase = true;
playersTurnManager.UpdatePlayerTurnAvailability(this.gameObject.name, turnAvailabilityEnum);
break;
case BaseEnum.THIRD_BASE:
Debug.Log("Get on THIRD BASE");
this.NextBase = BaseEnum.HOME_BASE;
this.HasReachedThirdBase = true;
playersTurnManager.UpdatePlayerTurnAvailability(this.gameObject.name, turnAvailabilityEnum);
break;
default:
Debug.Log("DO NOT KNOW WHAT HAPPEN");
break;
}
if (isNextRunnerTurnPossible)
{
playersTurnManager.TurnState = TurnStateEnum.RUNNER_TURN;
PlayersTurnManager.IsCommandPhase = true;
}
}
public static Dictionary <int, string> ToDic()
{
return(BaseEnum.ToDic(items));
}
public static Dictionary <string, int> ToStr2IntDic()
{
return(BaseEnum.ToStr2IntDic(items));
}
/// <summary>
/// Initiaze the global variable
/// </summary>
/// <param name="baseEnum">Selected baseenum element</param>
public CreateLabels_BaseEnum(BaseEnum baseEnum)
{
this.baseEnum = baseEnum;
}
//public TableDeMultiplication()
//{
// _size = 10;
// _mbase = BaseEnum.Decimale;
//}
public TableDeMultiplication(int sise, BaseEnum mbase)
{
_size = sise;
_mbase = mbase;
}
/// <summary>
/// 设置当前状态
/// </summary>
/// <param name="state"></param>
public void SetState(BaseEnum.PlayerState state)
{
if (m_PlayerState != state)
{
m_PlayerState = state;
}
}
/// <summary>
/// Retrieves the nodes of the current level of the project tree.
/// </summary>
/// <param name="request">Request.</param>
/// <param name="parentIds">Parent ids.</param>
/// <param name="path">Path elements.</param>
/// <param name="pageSize">Page size.</param>
/// <param name="pageNumber">Page number.</param>
/// <returns>Nodes of the current level of the project tree.</returns>
public HttpResponseMessage Post(HttpRequestMessage request, string parentIds, string path, int pageSize = 10, int pageNumber = 0)
{
// Parse and validate input parameters
string[] parentIdsParsed = ParseAndValidateParentIds(request, parentIds);
TreeNodePath pathParsed = ParseAndValidatePath(request, path);
if (parentIdsParsed.Length != pathParsed.Length)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest,
String.Format("Parent ids ('{0}') length ({1}) is not equal to path ('{2}') length ({3}).", parentIds, parentIdsParsed.Length, path, pathParsed.Length)));
}
// Process path by retrieving the object for every path element with the corresponding id from id chain
var linkBuilder = new LinkBuilder(Url);
Project project = null;
Database database = null;
BaseEnum baseEnum = null;
Entity entity = null;
Relation relation = null;
Guid lastId = Guid.Empty;
int i = 0;
foreach (var element in pathParsed)
{
lastId = this.ParseAndValidateId(request, parentIdsParsed[i]);
switch (element)
{
case Element.Project:
VerifyProjectId(request, parentIdsParsed[i], project);
break;
case Element.Database:
database = RetrieveDatabase(request, linkBuilder, parentIdsParsed[i], project);
break;
case Element.Folder_Diagrams:
RetrieveFolder(request, parentIdsParsed[i], database.Id);
break;
case Element.Folder_BaseEnums:
RetrieveFolder(request, parentIdsParsed[i], database.Id);
break;
case Element.Folder_DataTypes:
RetrieveFolder(request, parentIdsParsed[i], database.Id);
break;
case Element.Folder_Entities:
RetrieveFolder(request, parentIdsParsed[i], database.Id);
break;
case Element.Diagram:
throw new NotImplementedException(); // TODO: implement
case Element.BaseEnum:
baseEnum = RetrieveBaseEnum(request, linkBuilder, parentIdsParsed[i], database);
break;
case Element.Entity:
entity = RetrieveEntity(request, linkBuilder, parentIdsParsed[i], database);
break;
case Element.Folder_EntityAttributes:
RetrieveFolder(request, parentIdsParsed[i], entity.Id);
break;
case Element.Folder_EntityRelations:
RetrieveFolder(request, parentIdsParsed[i], entity.Id);
break;
case Element.Relation:
relation = RetrieveRelation(request, linkBuilder, parentIdsParsed[i], entity);
break;
default:
if (element != TreeNodePath.Root)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest,
String.Format("Element '{0}' is not expected at position {1} of the path '{2}'.", element, i, path)));
}
project = RetrieveProject(request, linkBuilder, parentIdsParsed[i]);
break;
}
i++;
}
// Retrieve nodes
var getTreeNodes = new GetTreeNodes();
QueryResult <TreeNode> treeNodes = getTreeNodes.Execute(ObjectTreeDataSource.ProjectTreeView, lastId, pathParsed, pageSize, pageNumber);
// Add links
foreach (var node in treeNodes.ResultSet)
{
node.AddLinks(linkBuilder, parentIds + IdSeparator + node.ObjectId, pathParsed);
}
// Wrap into the collection
var collection = this.WrapQueryResultIntoCollection <TreeNode>(treeNodes);
// Return the object
return(request.CreateResponse(HttpStatusCode.OK, collection));
}
TableDeMultiplication IMatrixMultiplicationFactory.buildMatrixMultiplication(int size, BaseEnum mbase)
{
TableDeMultiplication tableDeMultiplication = new TableDeMultiplication(size, mbase);
return(tableDeMultiplication);
//throw new NotImplementedException();
}
/// <summary>
/// 设置角色朝向
/// </summary>
/// <param name="orientation">朝向</param>
private void SetOrientation(BaseEnum.PlayerOrientation orientation)
{
if (m_PlayerOrientation != orientation)
{
m_PlayerOrientation = orientation;
}
}
