public Wall(int x, int y
, int length, Direction direction
, string display
)
{
X = x;
Y = y;
Length = length;
Direction = direction;
Display = display;
switch (direction)
{
case Direction.Horizontal:
Width = length;
Height = 1;
break;
case Direction.Vertical:
Height = length;
Width = 1;
break;
default:
throw new ArgumentOutOfRangeException(nameof(direction), direction, message: null);
}
Renderer = RenderFactory.CreateRenderableFor <IBlock>(this);
}
protected override void OnCreate(UnityEngine.Object asset)
{
if (asset == null)
{
return;
}
TextAsset desc = asset as TextAsset;
package = UIPackage.AddPackage(desc.bytes, null, (string name, string extension, Type type, out DestroyMethod destroyMethod) =>
{
destroyMethod = DestroyMethod.None;
string assetPath = string.Format("{0}/{1}_{2}.fui", uiMrg.windowFolder, package.name, name).ToLower();
UIPackageDependenceObject depence = null;
if (!loading.TryGetValue(assetPath, out depence))
{
if (!dependences.TryGetValue(assetPath, out depence))
{
depence = RenderFactory.CreateInstance <UIPackageDependenceObject>(assetPath, this);
loading.Add(assetPath, depence);
}
}
return(depence.asset);
});
}
public override void Render(TextWriter writer, RenderTypes renderTypes)
{
var renderer = RenderFactory.Create(renderTypes, ElementTypes.Hyperlink, this);
renderer.Render(writer);
if (renderTypes == RenderTypes.Html)
{
if (this.ChildElements.Count > 0)
{
base.Render(writer, renderTypes);
}
else
{
writer.Write(this.Url.HtmlEncode());
}
renderer = FinishRenderersFactory.Create(FinishTypes.Hyperlink, renderTypes, this);
renderer.Render(writer);
}
if (renderTypes == RenderTypes.Text)
{
base.Render(writer, renderTypes);
renderer = FinishRenderersFactory.Create(FinishTypes.Hyperlink, renderTypes, this);
renderer.Render(writer);
}
}
public GameWindow()
{
Text = "Game";
ShowIcon = false;
//ShowInTaskbar = false;
MaximizeBox = false;
StartPosition = FormStartPosition.CenterScreen;
//FormBorderStyle = FormBorderStyle.FixedSingle;
/*set the client size by default to 80% of screen size*/
Screen screen = Screen.FromPoint(Cursor.Position);
Size screenSize = screen.Bounds.Size;
ClientSize = new Size(
(int)(screenSize.Width * 0.8f),
(int)(screenSize.Height * 0.8f));
/*setup renderer*/
p_Renderer = RenderFactory.CreateRenderer();
RecreateContext();
}
public override void Render(TextWriter writer, RenderTypes renderTypes)
{
var renderer = RenderFactory.Create(renderTypes, ElementTypes.Paragraph, this);
renderer.Render(writer);
base.Render(writer, renderTypes);
renderer = FinishRenderersFactory.Create(FinishTypes.Paragraph, renderTypes, this);
renderer.Render(writer);
}
public void RecreateContext()
{
if (p_Context != null)
{
p_Context.Dispose();
}
p_Renderer = RenderFactory.CreateRenderer();
p_Context = RenderFactory.CreateContext(Handle);
}
public Fraction Calculate()
{
var a = _operations.Pop() as Fraction;
var op = _operations.Pop() as IOperator <Fraction>;
var b = _operations.Pop() as Fraction;
var result = op.Execute(a, b).Reduce();
var renderer = RenderFactory.GetRenderer(Mode);
return(renderer.Render(result));
}
public ResultsWindow(SolversHolder solversHolder, NodeCollectionStorage <FullConnectedGraph> storage)
{
InitializeComponent();
Loaded += delegate
{
var t = ResultsCanvas.Width;
};
Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Arrange(new Rect(0, 0, Width, Height));
_render = RenderFactory.GetResultRender(ResultsCanvas, solversHolder, storage);
//solversHolder.Solved += SolvedHandler;
}
public void Pause(params uint[] screenIndexs)
{
foreach (var index in screenIndexs)
{
if (CurrentWalpapers.ContainsKey(index))
{
var wallpaper = CurrentWalpapers[index];
var currentRender = RenderFactory.GetOrCreateRender(wallpaper.Type);
currentRender.Pause(screenIndexs);
}
}
}
public void Resum(params int[] screenIndexs)
{
foreach (var index in screenIndexs)
{
if (_currentWalpapers.ContainsKey(index))
{
var wallpaper = _currentWalpapers[index];
var currentRender = RenderFactory.GetOrCreateRender(wallpaper.Type.DType);
currentRender.Resum(screenIndexs);
}
}
}
static void Main(string[] args)
{
var activeView = new CreateEncounter(RenderFactory.GetRenderer(), new Guesser(names));
activeView.Focus();
activeView.Draw();
while (true)
{
activeView.KeyPressed(Console.ReadKey(true));
activeView.Draw();
}
}
public override void Render(TextWriter writer, RenderTypes renderTypes)
{
var renderer = RenderFactory.Create(renderTypes, ElementTypes.Document, this);
renderer.Render(writer);
base.Render(writer, renderTypes);
if (renderTypes == RenderTypes.Html)
{
renderer = FinishRenderersFactory.Create(FinishTypes.DocumentHtmlFinish, renderTypes, this);
renderer.Render(writer);
}
}
private void ApplyAudioSource()
{
//设置音源
for (uint screenIndex = 0; screenIndex < Screen.AllScreens.Length; screenIndex++)
{
if (CurrentWalpapers.ContainsKey(screenIndex))
{
var wallpaper = CurrentWalpapers[screenIndex];
var currentRender = RenderFactory.GetOrCreateRender(wallpaper.Type);
currentRender.SetVolume(screenIndex == Options.AudioScreenIndex ? 100 : 0, screenIndex);
}
}
}
public UIPackageAsset(string packageName, UIManager uiMrg, UIPackageDependenceAsset dependenceAsset)
{
this.uiMrg = uiMrg;
this.dependenceAsset = dependenceAsset;
List <string> dpFiles = dependenceAsset.GetDependenceFiles(packageName);
for (int i = 0; i < dpFiles.Count; i++)
{
string[] fileNames = dpFiles[i].Split('.');
string assetPath = string.Format("{0}/{1}.fui", uiMrg.windowFolder, fileNames[0]).ToLower();
UIPackageDependenceObject depence = RenderFactory.CreateInstance <UIPackageDependenceObject>(assetPath, this);
loading.Add(assetPath, depence);
}
}
private static void RunWithOptions(CommandLineOptions options)
{
var parameters = options.ToParameters();
var results = parameters.Seed
.Iterate(StringExtensions.Describe)
.Optionaly(parameters.MaxIterations, (source, maxIt) => source.Take(maxIt + 1)) // adding one since 0 is seed
.Profile()
.Optionaly(parameters.MaxTimePerIteration, (source, maxTime) => source.TakeWhileWithLast(profiled => profiled.Tag < maxTime))
;
RenderFactory
.Create(options.RenderType)
?.Render(parameters, results);
}
private UIPackageAsset LoadPackageAsync(string packageName)
{
UIPackageAsset package = null;
if (!m_PackageLoading.TryGetValue(packageName, out package))
{
if (!m_PackageAssets.TryGetValue(packageName, out package))
{
string descPath = string.Format("{0}/{1}_fui.fui", windowFolder, packageName).ToLower();
package = RenderFactory.CreateInstance <UIPackageAsset>(descPath, null, this);
m_PackageLoading.Add(packageName, package);
}
}
return(package);
}
public override void Initialize()
{
GameObject uiRoot = GameObject.Find("FairyGUI");
if (uiRoot == null)
{
throw new Exception("UIRoot is null.please create it.");
}
this.windowRoot = uiRoot.transform.Find("Windows");
this.windowFolder = "res/ui/fairygui";
this.windowCamera = uiRoot.transform.GetComponentInChildren <Camera>();
m_Instance = this;
ms_MutexGroups.Add(UIWindowGroup.Window);
AddRollbackGroup(UIWindowGroup.Window);
m_PackageDependenceAsset = RenderFactory.CreateInstance <UIPackageDependenceAsset>(string.Format("{0}/FairyGUIPackageDependences.fui", this.windowFolder), null);
}
private UIPackageAsset LoadPackage(string packageName)
{
UIPackageAsset package = null;
if (!m_PackageAssets.TryGetValue(packageName, out package))
{
string descPath = string.Format("{0}/{1}_fui.fui", windowFolder, packageName).ToLower();
package = RenderFactory.CreateInstance <UIPackageAsset>(descPath, null, packageName, this, m_PackageDependenceAsset);
m_PackageAssets.Add(packageName, package);
}
//加载依赖包
List <string> dependences = m_PackageDependenceAsset.GetDependencePackages(packageName);
for (int d = 0; d < dependences.Count; d++)
{
LoadPackage(dependences[d]);
}
package.ReferenceCount++;
return(package);
}
public async Task ShowWallpaper(WallpaperModel wallpaper, params uint[] screenIndexs)
{
if (wallpaper.Type == WallpaperType.NotSupport)
{
wallpaper.Type = RenderFactory.ResoveType(wallpaper.Path);
}
if (wallpaper.Type == WallpaperType.NotSupport)
{
return;
}
foreach (var index in screenIndexs)
{
//类型不一致关闭上次显示的壁纸
if (CurrentWalpapers.ContainsKey(index) && wallpaper.Type != CurrentWalpapers[index].Type)
{
CloseWallpaper(screenIndexs);
}
}
var currentRender = RenderFactory.GetOrCreateRender(wallpaper.Type);
await currentRender.ShowWallpaper(wallpaper, screenIndexs);
foreach (var index in screenIndexs)
{
if (!CurrentWalpapers.ContainsKey(index))
{
CurrentWalpapers.Add(index, wallpaper);
}
else
{
CurrentWalpapers[index] = wallpaper;
}
}
ApplyAudioSource();
}
public async Task ShowWallpaper(WallpaperModel wallpaper, params int[] screenIndexs)
{
//CloseWallpaper(screenIndexs);
if (wallpaper.Type == null)
{
wallpaper.Type = RenderFactory.ResoveType(wallpaper.Path);
}
if (wallpaper.Type.DType == WalllpaperDefinedType.NotSupport)
{
return;
}
foreach (var index in screenIndexs)
{
//类型不一致关闭上次显示的壁纸
if (_currentWalpapers.ContainsKey(index) && wallpaper.Type.DType != _currentWalpapers[index].Type.DType)
{
CloseWallpaper(screenIndexs);
}
}
var currentRender = RenderFactory.GetOrCreateRender(wallpaper.Type.DType);
await currentRender.ShowWallpaper(wallpaper, screenIndexs);
foreach (var index in screenIndexs)
{
if (!_currentWalpapers.ContainsKey(index))
{
_currentWalpapers.Add(index, wallpaper);
}
else
{
_currentWalpapers[index] = wallpaper;
}
}
}
/// <summary>
/// Constructor a helper class for <see cref="MainWindow"/> to request <see cref="RendererBase"/>
/// </summary>
/// <param name="renderFactory">a render factory to work with</param>
/// <param name="defualtRender">a default render to work with</param>
public RenderProvider(RenderFactory renderFactory, RenderMode defualtRender)
{
this.RenderFactory = renderFactory;
this.Renderer = this.RenderFactory.CreateRender(defualtRender);
}
public void GetRenderer_StandardMode_ReturnsAsExpected()
{
var result = RenderFactory.GetRenderer(Mode.Standard);
Assert.IsInstanceOfType(result, typeof(DefaultRenderer));
}
/// <summary>
/// Allows the game to perform any initialization it needs to before starting to run.
/// This is where it can query for any required services and load any non-graphic
/// related content. Calling base.Initialize will enumerate through any components
/// and initialize them as well.
/// </summary>
protected override void Initialize()
{
var assembly = Assembly.GetExecutingAssembly();
var resourceName = "NamelessRogue.log4net.config";
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
XmlConfigurator.Configure(LogManager.CreateRepository("NamelessRogue"), stream);
}
Log = LogManager.GetLogger(typeof(NamelessGame));
Log.Info("Application started");
SaveManager.Init();
CurrentGame = new GameInstance();
DebugDevice = this.GraphicsDevice;
//TODO: move to config later
int width = 40;
int height = 30;
var commanderEntity = new Entity();
Commander = new Commander();
commanderEntity.AddComponent(Commander);
settings = new GameSettings(width, height);
graphics.PreferredBackBufferWidth = (int)(GetActualCharacterWidth() + settings.HudWidth());
graphics.PreferredBackBufferHeight = GetActualCharacterHeight();
graphics.IsFullScreen = false;
graphics.PreferMultiSampling = false;
graphics.SynchronizeWithVerticalRetrace = true;
MyraEnvironment.Game = this;
RenderTarget = new RenderTarget2D(
GraphicsDevice,
GraphicsDevice.PresentationParameters.BackBufferWidth,
GraphicsDevice.PresentationParameters.BackBufferHeight,
false,
GraphicsDevice.PresentationParameters.BackBufferFormat,
DepthFormat.Depth24, 4, RenderTargetUsage.PlatformContents);
graphics.ApplyChanges();
//12345 123
worldSettings = new WorldSettings(4, WorldGenConstants.Resolution, WorldGenConstants.Resolution);
TerrainFurnitureFactory.CreateFurnitureEntities(this);
ContextFactory.InitAllContexts(this);
var viewportEntity = RenderFactory.CreateViewport(settings);
CameraEntity = viewportEntity;
TimelineEntity = TimelineFactory.CreateTimeline(this);
var libraries = new Entity();
var ammoLibrary = new AmmoLibrary();
ammoLibrary.AmmoTypes.Add(new AmmoType()
{
Name = "Revolver ammo"
});
libraries.AddComponent(ammoLibrary);
var timelinEntity = TimelineEntity;
var timeline = timelinEntity.GetComponentOfType <TimeLine>();
WorldTile firsTile = null;
foreach (var worldBoardWorldTile in timeline.CurrentTimelineLayer.WorldTiles)
{
if (worldBoardWorldTile.Settlement != null)
{
firsTile = worldBoardWorldTile;
break;
}
}
int x, y;
if (firsTile != null)
{
//place everything at the center of newly generated settlement;
x = firsTile.Settlement.Concrete.Center.X;
y = firsTile.Settlement.Concrete.Center.Y;
}
else
{
x = WorldGenConstants.Resolution / 2;
y = WorldGenConstants.Resolution / 2;
}
var player = CharacterFactory.CreateSimplePlayerCharacter(x, y, this);
PlayerEntity = player;
FollowedByCameraEntity = player;
ChunkManagementSystem chunkManagementSystem = new ChunkManagementSystem();
//initialize reality bubble
chunkManagementSystem.Update(0, this);
//for (int i = 1; i < 10; i++)
//{
// for (int j = 1; j < 10; j++)
// {
// Entities.Add(CharacterFactory.CreateBlankNpc(x - i,
// y - j));
// }
//}
CharacterFactory.CreateBlankNpc(x - 6,
y, this);
//Entities.Add(CharacterFactory.CreateBlankNpc(x - 3,
// y));
//Entities.Add(CharacterFactory.CreateBlankNpc(x - 5,
// y));
//Entities.Add(CharacterFactory.CreateBlankNpc(x - 7,
// y));
for (int i = 0; i < 2; i++)
{
var sword = ItemFactory.CreateSword(x - 2,
y, i, this);;
}
var platemail = ItemFactory.CreatePlateMail(x - 2, y, 1, this);
var pants = ItemFactory.CreatePants(x - 2, y, 1, this);
var boots = ItemFactory.CreateBoots(x - 2, y, 1, this);
var cape = ItemFactory.CreateCape(x - 2, y, 1, this);
var ring = ItemFactory.CreateRing(x - 2, y, 1, this);
var shield = ItemFactory.CreateShield(x - 2, y, 1, this);
var helmet = ItemFactory.CreateHelmet(x - 2, y, 1, this);
var ammo1 = ItemFactory.CreateLightAmmo(x - 1, y, 1, 20, this, ammoLibrary);
var ammo2 = ItemFactory.CreateLightAmmo(x - 1, y + 1, 1, 20, this, ammoLibrary);
var revolver = ItemFactory.CreateRevolver(x + 2, y + 1, 1, this, ammoLibrary);
var pArmor = ItemFactory.CreatePowerArmor(x - 2, y, 1, this);
Point worldRiverPosition = new Point();
bool anyRivers = false;
foreach (var worldBoardWorldTile in timeline.CurrentTimelineLayer.WorldTiles)
{
var pos = worldBoardWorldTile.WorldBoardPosiiton;
var isWater = timeline.CurrentTimelineLayer.InlandWaterConnectivity[pos.X][pos.Y].isWater;
if (isWater)
{
anyRivers = true;
worldRiverPosition = pos;
break;
}
}
if (anyRivers)
{
//move player to some river
PlayerEntity.GetComponentOfType <Position>().Point = new Point(worldRiverPosition.X * Constants.ChunkSize, worldRiverPosition.Y * Constants.ChunkSize);
chunkManagementSystem.Update(0, this);
}
CursorEntity = GameInitializer.CreateCursor();
//Paragraph.BaseSize = 1.175f;
//UserInterface.Initialize(Content, "custom");
//UserInterface.Active.UseRenderTarget = true;
CurrentContext = ContextFactory.GetMainMenuContext(this);
CurrentContext.ContextScreen.Show();
this.IsMouseVisible = true;
// UserInterface.Active.ShowCursor = false;
spriteBatch = new SpriteBatch(GraphicsDevice);
fpsLabel = new Label();
fpsLabel.HorizontalAlignment = HorizontalAlignment.Right;
ContextFactory.GetIngameContext(this).ContextScreen.Panel.Widgets.Add(fpsLabel);
var stackPanel = new VerticalStackPanel();
stackPanel.Widgets.Add(fpsLabel);
// Desktop.Widgets.Add(stackPanel);
// Inform Myra that external text input is available
// So it stops translating Keys to chars
_desktop.HasExternalTextInput = true;
// Provide that text input
Window.TextInput += (s, a) =>
{
_desktop.OnChar(a.Character);
};
}
public void GetRenderer_BuilderMode_ReturnsAsExpected()
{
var result = RenderFactory.GetRenderer(Mode.Builder);
Assert.IsInstanceOfType(result, typeof(BuilderRenderer));
}
public override void Render(TextWriter writer, RenderTypes renderTypes)
{
var renderer = RenderFactory.Create(renderTypes, ElementTypes.TextElement, this);
renderer.Render(writer);
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string outputCodeDir = args.OutputCodeDir;
timer.StartPhase("build defines");
var loader = new ProtoDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
var ass = new DefAssembly();
ass.Load(rawDefines, agent, args);
var targetService = args.Service;
List <DefTypeBase> exportTypes = ass.GetExportTypes();
var tasks = new List <Task>();
var genCodeFiles = new ConcurrentBag <FileInfo>();
var genScatteredFiles = new ConcurrentBag <FileInfo>();
var genType = args.GenType;
var render = RenderFactory.CreateRender(genType);
if (render == null)
{
throw new NotSupportedException($"not support gen type:{genType}");
}
ass.CurrentLanguage = RenderFileUtil.GetLanguage(genType);
render.Render(new GenContext()
{
GenArgs = args,
Assembly = ass,
Lan = ass.CurrentLanguage,
GenType = genType,
Render = render,
Tasks = tasks,
ExportTypes = exportTypes,
GenCodeFilesInOutputCodeDir = genCodeFiles,
GenScatteredFiles = genScatteredFiles,
});
await Task.WhenAll(tasks.ToArray());
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFiles.ToList()
});
res.ScatteredFiles.AddRange(genScatteredFiles);
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = ExceptionUtil.ExtractMessage(e);
res.StackTrace = e.StackTrace;
}
DefAssemblyBase.LocalAssebmly = null;
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
public Player(int x, int y)
{
X = x;
Y = y;
Renderer = RenderFactory.CreateRenderableFor <IPositioned>(this);
}
public async Task GenAsync(RemoteAgent agent, GenJob rpc)
{
var res = new GenJobRes()
{
ErrCode = Luban.Common.EErrorCode.OK,
ErrMsg = "succ",
FileGroups = new List <FileGroup>(),
};
if (!TryParseArg(rpc.Arg.JobArguments, out GenArgs args, out string errMsg))
{
res.ErrCode = Luban.Common.EErrorCode.JOB_ARGUMENT_ERROR;
res.ErrMsg = errMsg;
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
return;
}
var timer = new ProfileTimer();
timer.StartPhase("= gen_all =");
try
{
string inputDataDir = args.InputDataDir;
string outputCodeDir = args.OutputCodeDir;
string outputDataDir = args.OutputDataDir;
var genTypes = args.GenType.Split(',').Select(s => s.Trim()).ToList();
timer.StartPhase("build defines");
var loader = new CfgDefLoader(agent);
await loader.LoadAsync(args.DefineFile);
await loader.LoadDefinesFromFileAsync(inputDataDir);
timer.EndPhaseAndLog();
var rawDefines = loader.BuildDefines();
TimeZoneInfo timeZoneInfo = string.IsNullOrEmpty(args.L10nTimeZone) ? null : TimeZoneInfo.FindSystemTimeZoneById(args.L10nTimeZone);
var excludeTags = args.OutputExcludeTags.Split(',').Select(t => t.Trim().ToLowerInvariant()).Where(t => !string.IsNullOrEmpty(t)).ToList();
var ass = new DefAssembly(args.L10nPatchName, timeZoneInfo, excludeTags, agent);
ass.Load(rawDefines, agent, args);
List <DefTable> exportTables = ass.GetExportTables();
List <DefTypeBase> exportTypes = ass.GetExportTypes();
bool hasLoadCfgData = false;
bool needL10NTextConvert = !string.IsNullOrWhiteSpace(args.L10nInputTextTableFiles);
async Task CheckLoadCfgDataAsync()
{
if (!hasLoadCfgData)
{
hasLoadCfgData = true;
var timer = new ProfileTimer();
timer.StartPhase("load config data");
await DataLoaderUtil.LoadCfgDataAsync(agent, ass, args.InputDataDir, args.L10nPatchName, args.L10nPatchInputDataDir, args.InputConvertDataDir);
timer.EndPhaseAndLog();
if (needL10NTextConvert)
{
ass.InitL10n(args.L10nTextValueFieldName);
await DataLoaderUtil.LoadTextTablesAsync(agent, ass, ".", args.L10nInputTextTableFiles);
}
timer.StartPhase("validate");
var validateCtx = new ValidatorContext(ass, args.ValidateRootDir);
await validateCtx.ValidateTables(ass.GetAllTables());
timer.EndPhaseAndLog();
}
}
var tasks = new List <Task>();
var genCodeFilesInOutputCodeDir = new ConcurrentBag <FileInfo>();
var genDataFilesInOutputDataDir = new ConcurrentBag <FileInfo>();
var genScatteredFiles = new ConcurrentBag <FileInfo>();
foreach (var genType in genTypes)
{
var ctx = new GenContext()
{
GenType = genType,
Assembly = ass,
GenArgs = args,
ExportTypes = exportTypes,
ExportTables = exportTables,
GenCodeFilesInOutputCodeDir = genCodeFilesInOutputCodeDir,
GenDataFilesInOutputDataDir = genDataFilesInOutputDataDir,
GenScatteredFiles = genScatteredFiles,
Tasks = tasks,
DataLoader = CheckLoadCfgDataAsync,
};
GenContext.Ctx = ctx;
var render = RenderFactory.CreateRender(genType);
if (render == null)
{
throw new Exception($"unknown gentype:{genType}");
}
if (render is DataRenderBase)
{
await CheckLoadCfgDataAsync();
}
render.Render(ctx);
GenContext.Ctx = null;
}
await Task.WhenAll(tasks.ToArray());
if (needL10NTextConvert)
{
var notConvertTextList = DataExporterUtil.GenNotConvertTextList(ass.NotConvertTextSet);
var md5 = FileUtil.CalcMD5(notConvertTextList);
string outputNotConvertTextFile = args.L10nOutputNotTranslatedTextFile;
CacheManager.Ins.AddCache(outputNotConvertTextFile, md5, notConvertTextList);
genScatteredFiles.Add(new FileInfo()
{
FilePath = outputNotConvertTextFile, MD5 = md5
});
}
if (!genCodeFilesInOutputCodeDir.IsEmpty)
{
res.FileGroups.Add(new FileGroup()
{
Dir = outputCodeDir, Files = genCodeFilesInOutputCodeDir.ToList()
});
}
if (!genDataFilesInOutputDataDir.IsEmpty)
{
res.FileGroups.Add(new FileGroup()
{
Dir = outputDataDir, Files = genDataFilesInOutputDataDir.ToList()
});
}
if (!genScatteredFiles.IsEmpty)
{
res.ScatteredFiles.AddRange(genScatteredFiles);
}
}
catch (DataCreateException e)
{
res.ErrCode = Luban.Common.EErrorCode.DATA_PARSE_ERROR;
res.ErrMsg = $@"
=======================================================================
解析失败!
文件: {e.OriginDataLocation}
错误位置: {e.DataLocationInFile}
Err: {e.OriginErrorMsg}
字段: {e.VariableFullPathStr}
=======================================================================
";
res.StackTrace = e.OriginStackTrace;
}
catch (Exception e)
{
res.ErrCode = Luban.Common.EErrorCode.JOB_EXCEPTION;
res.ErrMsg = $@"
=======================================================================
{ExceptionUtil.ExtractMessage(e)}
=======================================================================
";
res.StackTrace = e.StackTrace;
}
DefAssemblyBase.LocalAssebmly = null;
timer.EndPhaseAndLog();
agent.Session.ReplyRpc <GenJob, GenJobArg, GenJobRes>(rpc, res);
}
