/// <summary>
/// 取得输出目录.
/// </summary>
/// <returns>The output dir.</returns>
/// <param name="iTarget">打包目标类型.</param>
/// <param name="iBuildNo">打包No.</param>
/// <param name="iOutputDir">输出目录（未指定：默认输出根目录）.</param>
private static string GetOutputDir(BuildTarget iTarget, int iBuildNo, string iOutputDir = null)
{
var outputDir = iOutputDir;
if (string.IsNullOrEmpty(outputDir))
{
outputDir = DefaultOutputRootDir;
}
// 校验目录
outputDir = $"{outputDir}/{iBuildNo}/{iTarget.ToString()}";
// 日志输出目录
Loger.OutputDir = $"{outputDir}/Logs";
Loger.BuildLog($"GetOutputDir() -> LogDir:{Loger.OutputDir}");
// 工程输出目录
if (BuildTarget.iOS == iTarget)
{
outputDir = $"{outputDir}/XcodeProject";
}
// 校验 - 日志输出目录
if (UtilsTools.CheckAndCreateDirByFullDir(Loger.OutputDir) == false)
{
Loger.BuildErrorLog($"CheckAndCreateDirByFullDir Failed!!(dir:{Loger.OutputDir})");
}
// 校验 - 打包输出目录
if (UtilsTools.CheckAndCreateDirByFullDir(outputDir) == false)
{
Loger.BuildErrorLog($"CheckAndCreateDirByFullDir Failed!!(dir:{outputDir})");
}
Loger.BuildLog($"GetOutputDir() -> Dir:{outputDir}");
return(outputDir);
}
public void ShowAnsuerPopup(MTTestModel objTest)
{
if (objTest.WasCorrect == null)
{
MTMapUser ansuerUser = CurrentAsuerPopup.FindName("_Map") as MTMapUser;
//Set Map stage
if (objTest.Patch.Score < MTControler.Settings.Stg1to2)
{
MTLibraryModel.Stage = TestStage.Stage_1;
}
else if (objTest.Patch.Score < MTControler.Settings.Stg2to3)
{
MTLibraryModel.Stage = TestStage.Stage_2;
}
else
{
MTLibraryModel.Stage = TestStage.Stage_3;
}
ansuerUser.MapMode = objTest.Type;
ansuerUser.Action = new DoSomeThing(objTest.Action);
Grid objGrid = UtilsTools.GetChild(lbTest, lbTest.SelectedIndex, "GridTest") as Grid;
CurrentAsuerPopup.PlacementTarget = objGrid;
foreach (MTMapModel objMap in ansuerUser.lvMap.Items)
{
objMap.FirePropertyChanged("Color");
}
CurrentAsuerPopup.IsOpen = true;
switch (ansuerUser.MapMode)
{
case TestType.AskAdrees:
ansuerUser.SetSelectedVersesList(objTest.LstAnsuer);
ansuerUser.tbTextAdres.Text = (objTest as MTTestAskAdreesModel).PreviosText;
if (MTLibraryModel.Stage == TestStage.Stage_3)
{
ansuerUser.tbTextAdres.Focus();
}
else
{
ansuerUser.lvMap.Focus();
}
break;
case TestType.AskText:
ansuerUser.tbSearch.Text = (objTest as MTTestAskTextModel).Fragment;
ansuerUser.tbSearch.Focus();
break;
}
}
}
/// <summary>
/// 清空Plugins/Android目录.
/// </summary>
private static void ClearPluginsAndroid()
{
var dir = $"{Application.dataPath}/Plugins/Android";
if (false == UtilsTools.CheckAndCreateDir(dir))
{
return;
}
// 清空目录
UtilsTools.ClearDirectory(dir);
}
/// <summary>
/// 重置Plugins/Android.
/// </summary>
private static void ResetPluginsAndroid()
{
var fromDir = $"{Application.dataPath}/../AndroidPlatform/Default";
if (false == UtilsTools.CheckAndCreateDir(fromDir))
{
return;
}
var toDir = $"{Application.dataPath}/Plugins/Android";
if (false == UtilsTools.CheckAndCreateDir(toDir))
{
return;
}
// 拷贝文件
var dirInfo = new DirectoryInfo(fromDir);
var allFiles = dirInfo.GetFiles();
if (1 <= allFiles.Length)
{
foreach (var file in allFiles)
{
if (file.Name.EndsWith(".meta"))
{
continue;
}
// 拷贝文件
var copyToFile = $"{toDir}/{file.Name}";
Loger.BuildLog($"Copy File : {file.FullName} -> {copyToFile}");
File.Copy(file.FullName, copyToFile, true);
}
}
// 检索子文件夹
var subDirs = dirInfo.GetDirectories();
if (1 > subDirs.Length)
{
return;
}
foreach (var subDir in subDirs)
{
var subFromDir = $"{fromDir}/{subDir.Name}";
// 拷贝
UtilsTools.CopyDirectory(subFromDir, toDir);
}
}
/// <summary>
/// 初始化标题信息.
/// </summary>
/// <param name="iTarget">目标信息.</param>
protected virtual void InitTitleInfo(T1 iTarget)
{
if (string.IsNullOrEmpty(ImportDir))
{
ImportDir = UtilsTools.CheckMatchPath(AssetSetting.GetImportPath());
}
DrawLabel(0, "Import Dir", Color.white, ImportDir);
if (string.IsNullOrEmpty(ExportDir))
{
ExportDir = UtilsTools.CheckMatchPath(AssetSetting.GetExportPath());
}
DrawLabel(0, "Export Dir", Color.white, ExportDir);
}
/// <summary>
/// 初始化标题信息.
/// </summary>
/// <param name="iTarget">目标信息.</param>
protected virtual void InitTitleInfo(T1 iTarget)
{
if (string.IsNullOrEmpty(ImportDir))
{
ImportDir = UtilsTools.CheckMatchPath(AssetSetting.GetImportPath());
}
EditorGUILayout.LabelField("Import Dir", ImportDir);
if (string.IsNullOrEmpty(ExportDir))
{
ExportDir = UtilsTools.CheckMatchPath(AssetSetting.GetExportPath());
}
EditorGUILayout.LabelField("Export Dir", ExportDir);
}
public override void InitializeRichTextBox()
{
ListView lvTest = MTControler.DlgTest.lbTest;
RichTextBox objRtbox = UtilsTools.GetChild(lvTest, lvTest.Items.IndexOf(this), "rtbText") as RichTextBox;
if (objRtbox == null)
{
return;
}
objRtbox.Document.Blocks.Clear();
objRtbox.Document.Blocks.Add(GetParagAsk());
}
public override void Action(MTMapUser ansuerUser)
{
_LstAnsuer = ansuerUser.SelectedPatchClone;
_sFragment = ansuerUser.tbSearch.Text;
string sText = MTControler.GetAdrees(ansuerUser.SelectedPatch, false);
AnsuerToShow = (sText == "" ? _sAnsuer : sText);
ListView lvTest = MTControler.DlgTest.lbTest;
RichTextBox objRtbox = UtilsTools.GetChild(lvTest, lvTest.Items.IndexOf(this), "rtbText") as RichTextBox;
objRtbox.Document.Blocks.Clear();
objRtbox.Document.Blocks.Add(GetParagAsk());
objRtbox.Document.Blocks.Add(GetSearchedText());
}
/// <summary>
/// 添加对象.
/// </summary>
/// <param name="iTarget">对象.</param>
/// <param name="iFileType">上传文件类型.</param>
/// <param name="iHashCode">HashCode(Unity3d打包生成).</param>
public void AddTarget(
BundleMap iTarget, BundleFileType iFileType, string iHashCode = null)
{
if (iTarget == null)
{
return;
}
BundlesResultItem item;
var filePath = GetLocalBundleFilePath(
iTarget.id, iFileType, (BundleType.Scene == iTarget.type));
string checkCode = null;
string dataSize = null;
if (false == string.IsNullOrEmpty(filePath) &&
File.Exists(filePath))
{
checkCode = CheckMode.Unity3dHash128 == CheckMode ? iHashCode : UtilsTools.GetMd5ByFilePath(filePath);
var fileInfo = new FileInfo(filePath);
dataSize = fileInfo.Length.ToString();
}
else
{
this.Warning("AddTarget()::Target File is not exist!!!(ProjectName:{0})", filePath);
}
var exist = IsTargetExist(iTarget.id, iFileType, out item);
if (false == exist)
{
item = CreateBundleItem(iTarget.id, iTarget.type, iFileType);
item.checkCode = checkCode;
item.dataSize = dataSize;
}
else
{
if (false == string.IsNullOrEmpty(checkCode) &&
false == checkCode.Equals(item.checkCode))
{
item.checkCode = checkCode;
item.dataSize = dataSize;
item.uploaded = false;
}
}
UtilsAsset.SetAssetDirty(this);
}
/// <summary>
/// 拷贝库资源文件.
/// </summary>
public void CopyResources()
{
var copyFromDir = GetAndroidCopyFromDir();
var copyToDir = GetAndroidCopyToDir();
// Libs
var files = Directory.GetFiles(copyFromDir);
foreach (var file in files)
{
if (file.EndsWith("AndroidManifest.xml"))
{
continue;
}
if (file.EndsWith(".meta"))
{
continue;
}
var lastIndex = file.LastIndexOf("/", StringComparison.Ordinal);
var fileName = file.Substring(lastIndex + 1);
if (string.IsNullOrEmpty(fileName))
{
continue;
}
var copyToFile = $"{copyToDir}/{fileName}";
if (File.Exists(copyToFile))
{
File.Delete(copyToFile);
}
this.Info("CopyResources()::Copy Libs : {0} -> {1}",
file, copyToFile);
File.Copy(file, copyToFile);
}
// res
var copyRes = $"{copyFromDir}/res";
if (Directory.Exists(copyRes))
{
UtilsTools.CopyDirectory(copyRes, copyToDir);
}
}
/// <summary>
/// 导出成JSON文件.
/// </summary>
/// <returns>导出文件(Json格式).</returns>
/// <param name="iExportDir">导出路径.</param>
public virtual string ExportToJsonFile(string iExportDir)
{
var exportDir = iExportDir;
if (string.IsNullOrEmpty(exportDir))
{
exportDir = JsonPath;
}
var fileInfo = new FileInfo(JsonPath);
if (fileInfo.Directory != null && UtilsTools.CheckAndCreateDirByFullDir(fileInfo.Directory.FullName))
{
return(UtilsAsset.ExportData <T1>(data, exportDir));
}
this.Error("ExportToJsonFile -> CheckAndCreateDirByFullDir Failed!!! \n (AssetPath:{0})",
JsonPath);
return(null);
}
public override void InitializeRichTextBox()
{
ListView lvTest = MTControler.DlgTest.lbTest;
RichTextBox objRtbox = UtilsTools.GetChild(lvTest, lvTest.Items.IndexOf(this), "rtbText") as RichTextBox;
if (objRtbox != null)
{
objRtbox.Document.Blocks.Clear();
if (Patch.Score < MTControler.Settings.Stg2to3)
{
objRtbox.Document.Blocks.Add(GetParagAsk("#"));
}
else
{
objRtbox.Document.Blocks.Add(GetParagAsk(""));
}
}
}
/// <summary>
/// 自动生成Chunk
/// </summary>
/// <param name="iData">Tile数据</param>
private void AutoCreateTerrains(TerrainEditorData.TerrainTileData iData)
{
_terrainsRoot = new GameObject(TerrainsRootName);
for (var x = 0; x < ConfData.TileSize.x; ++x)
{
for (var z = 0; z < ConfData.TileSize.y; ++z)
{
var terrainObj = new GameObject();
terrainObj.name = string.Format("terrain_x{0}_z{1}", x, z);
// 设定父节点
terrainObj.transform.parent = _terrainsRoot.transform;
var terrain = terrainObj.AddComponent <UnityEngine.Terrain>();
var terrainCollider = terrainObj.AddComponent <TerrainCollider>();
// 深拷贝地形数据
var tmpData = UtilsTools.DeepCopy(iData.Data) as UnityEngine.TerrainData;
// 设置地形
if (terrain && tmpData)
{
// 设定尺寸(长x宽x高)
var size = ConfData.tileData.TerrainSize;
tmpData.size = size;
terrain.terrainData = tmpData;
// 设定位置
// Z 方向
var posX = size.x * x + size.x / 2;
var posZ = size.z * z + size.z / 2;
terrain.transform.localPosition = new Vector3(posX, 0.0f, posZ);
}
// 设置地形碰撞
if (terrainCollider && tmpData)
{
terrainCollider.terrainData = tmpData;
}
}
}
}
/// <summary>
/// 拆分地形
/// </summary>
/// <param name="iLevel">层级(影响到左边缩进的余白)</param>
private void SplitTerrains(int iLevel)
{
var level = iLevel;
DrawMiddleGameObject(
level, "地形根节点：", ref _terrainsRoot);
var childCount = 0;
if (!_terrainsRoot)
{
return;
}
childCount = _terrainsRoot.transform.childCount;
// 若长宽地形个数不想等
if (false == UtilsTools.IsSquare(childCount))
{
DrawLabel(level + 1, "地形部署长宽不相同(不是 N x N 布局)!", Color.red);
}
else
{
// 保存地形Tile尺寸
if (Math.Abs(ConfData.TileSize.x * ConfData.TileSize.y - childCount) > 0.0f)
{
ConfData.TileSize.x = (float)Math.Sqrt(childCount);
ConfData.TileSize.y = ConfData.TileSize.x;
}
DrawMiddleLabel(level, "chunk拆分数：");
++level;
DrawLabel(level, "因为与到处高度图相关，拆分个数必须为2的N次幂(1~64)", Color.yellow);
var lastSlicingCount = ConfData.chunkData.SlicingCount;
DrawMiddleSlider(
level, "个数( N x N )：", ref lastSlicingCount,
1.0f, 64);
if (!UtilsTools.IsPowerOf2((int)lastSlicingCount))
{
var error = string.Format("{0} 不是2的N次幂(1~64)！",
(int)ConfData.chunkData.SlicingCount);
DrawLabel(level + 1, error, Color.red);
}
else
{
if (Math.Abs(lastSlicingCount - ConfData.chunkData.SlicingCount) > 0.0f)
{
// 有变化贼，晴空已有数据
Settings.Clear();
ConfData.chunkData.SlicingCount = lastSlicingCount;
// 清空Debug用绘制节点
ClearDebugNode();
// 层级预览信息清空
_layerPreviewTitles.Clear();
_layerPreviewSelected.Clear();
}
// 分界线
DrawLongLabel(0, "---------------");
DrawSingleLongToggle(level, "是否预览拆分边界：", _chunkBoundPreviewVisiable,
delegate(bool iValue) { _chunkBoundPreviewVisiable = iValue; });
// 选择层级
// 取得最高层级
var maxLayerLevel = GetMaxLayerLevel((int)ConfData.chunkData.SlicingCount);
// 层级菜单标题
if (0 >= _layerPreviewSelected.Count)
{
for (var l = 0; l <= maxLayerLevel; ++l)
{
_layerPreviewTitles.Add(string.Format("层级{0}", l));
_layerPreviewSelected.Add(false);
}
}
if (_chunkBoundPreviewVisiable)
{
// 各层级显示
DrawLongLabel(level + 1, string.Format("当前拆分数可分 {0} 层：", maxLayerLevel + 1));
DrawMiddleMultiplyToggle(level + 2, _layerPreviewTitles.ToArray(), _layerPreviewSelected.ToArray(),
delegate(int l, bool iSelected) {
_layerPreviewSelected[l] = iSelected;
if (!iSelected)
{
ClearDebugNode(l);
}
});
// 显示颜色设定
var flg = false;
for (var l = 0; l <= maxLayerLevel; ++l)
{
if (!_layerPreviewSelected[l])
{
continue;
}
flg = true;
}
if (flg)
{
var layerPreview = ConfData.chunkData.Preview;
DrawLongLabel(level + 3, "颜色设定：");
DrawMiddleColor(level + 4, "边色", layerPreview.edgeColor,
delegate(Color iColor)
{
layerPreview.edgeColor = iColor;
// 重置所有边的颜色
UtilsDraw.ResetAllCylinderColor(iColor,
(int)DrawType.TerrainChunkCylinder);
});
DrawMiddleColor(level + 4, "顶点色", layerPreview.vertexColor,
delegate(Color iColor)
{
layerPreview.vertexColor = iColor;
// 重置所有边的颜色
UtilsDraw.ResetAllVertexColor(iColor,
(int)DrawType.TerrainChunkVertex);
});
DrawMiddleSlider(level + 4, "缩放",
layerPreview.Scale, delegate(float iValue)
{
layerPreview.Scale = iValue;
UtilsDraw.ResetAllBoundsPreviewScale(
iValue, (int)DrawType.TerrainChunkCylinder | (int)DrawType.TerrainChunkVertex);
},
1.0f, 50.0f);
--level;
}
// 遍历根节点并取得包围盒
if (null == _terrainsRoot)
{
return;
}
// 基准原点：子节点中最小的点为为基准原点(既：最左最前的为第一块地形Tile)
// 其他的地形都以该地形位置准排布
var baseOriginPos = GetOriginPosOfTerrainsFromTiles(_terrainsRoot.transform);
var terrainTileSize = Vector3.zero;
for (var i = 0; i < _terrainsRoot.transform.childCount; ++i)
{
var child = _terrainsRoot.transform.GetChild(i);
if (null == child)
{
continue;
}
if (false == child.gameObject.activeInHierarchy)
{
continue;
}
// 地形Tile尺寸
if (Vector3.zero.Equals(terrainTileSize))
{
terrainTileSize = TerrainsSettings.GetTerrainSize(child.gameObject);
}
// Tile Index
var tileIndex = GetTerrainTileIndexByPos(
baseOriginPos, child.transform.position,
terrainTileSize);
// 按照层级生成解析用的地形层级数据
for (var layerIndex = 0; layerIndex <= maxLayerLevel; ++layerIndex)
{
// 当前层级的chunk尺寸
var layerChunkSize = TerrainsSettings.GetTerrainChunkSize(
terrainTileSize, maxLayerLevel, layerIndex);
// 拆分当前层级的chunk数据
Settings.ParserTerrainTileData(
tileIndex, layerChunkSize, maxLayerLevel,
layerIndex);
}
for (var l = 0; l <= maxLayerLevel; ++l)
{
if (!_layerPreviewSelected[l])
{
continue;
}
// 取得当前层级的chunk信息
var chunks = Settings.GetChunkData(l);
if (null == chunks || 0 >= chunks.Count)
{
continue;
}
var bounds = new List <Bounds>();
// 以莫顿码为chunk索引
var chunksIndex = new List <int>();
foreach (var chunk in chunks)
{
bounds.Add(chunk.Bounds);
chunksIndex.Add((int)chunk.Morton);
}
// 绘制Chunks包围盒
var layerPreview = ConfData.chunkData.Preview;
if (null == layerPreview)
{
continue;
}
UtilsDraw.DrawChunkBounds(
bounds.ToArray(), chunksIndex.ToArray(),
child.transform,
layerPreview.edgeColor, layerPreview.vertexColor, layerPreview.Scale, l);
}
}
Settings.AutoSort();
}
else
{
ClearDebugNode();
}
DrawLongLabel(0, "---------------");
DrawLongLabel(0, "拆分设定：");
DrawLongLabel(1, "数据导入/导出目录：");
DrawLabel(2, string.Format("Chunk : {0}", Settings.ChunkDataDir), Color.green);
DrawLabel(2, string.Format("预制体 : {0}", Settings.PrefabsDataDir), Color.green);
DrawSingleMiddleToggle(1, "仅处理静态物体:", ConfData.chunkData.StaticOnly,
delegate(bool iValue) { ConfData.chunkData.StaticOnly = iValue; });
// 地形导出层级
DrawSelectList(1, "地形导出层级:", _layerPreviewTitles.ToArray(), ref _exportLayerLevel);
// 预制体导出深度
DrawMiddleSlider(1, "预制体导出深度:",
ConfData.chunkData.PrefabsExportDepthLimit,
delegate(float iValue) { ConfData.chunkData.PrefabsExportDepthLimit = (int)iValue; },
1.0f, 15.0f);
DrawSingleButton(0, "拆分场景",
delegate()
{
// 显示处理进度条
ProgressBarStart("拆分地形", "开始拆分...");
// Chunk导出目录检测
var dirInfo = new DirectoryInfo(Settings.ChunkDataDir);
UtilsTools.CheckAndCreateDirByFullDir(dirInfo.FullName);
// 清空保存目录，但不删除目录本身
UtilsTools.ClearDirectory(TerrainsSettings.DataBaseDir, false);
// 遍历根节点并取得包围盒
if (null == _terrainsRoot)
{
return;
}
// 基准原点：子节点中最小的点为为基准原点(既：最左最前的为第一块地形Tile)
// 其他的地形都以该地形位置准排布
var baseOriginPos = GetOriginPosOfTerrainsFromTiles(_terrainsRoot.transform);
var terrainTileSize = Vector3.zero;
var maxCount = _terrainsRoot.transform.childCount * ConfData.chunkData.SlicingCount *
ConfData.chunkData.SlicingCount;
var progressCount = 0;
for (var i = 0; i < _terrainsRoot.transform.childCount; ++i)
{
var child = _terrainsRoot.transform.GetChild(i);
if (null == child)
{
continue;
}
if (false == child.gameObject.activeInHierarchy)
{
continue;
}
// 地形Tile尺寸
if (Vector3.zero.Equals(terrainTileSize))
{
terrainTileSize = TerrainsSettings.GetTerrainSize(child.gameObject);
}
// Tile Index
var tileIndex = GetTerrainTileIndexByPos(
baseOriginPos, child.transform.position,
terrainTileSize);
// 拆分地形
TerrainsSplit.Instance.SplitTerrains(
Settings.ChunkDataDir, child.gameObject, tileIndex,
maxLayerLevel, maxLayerLevel - _exportLayerLevel,
delegate(string iStatusTxt, bool iStatusCount)
{
if (iStatusCount)
{
++progressCount;
}
// 计算进度
var progress = progressCount / maxCount;
ProgressBarUpdate(iStatusTxt, progress);
this.Info("SplitTerrains:({0}) {1}", progress, iStatusTxt);
});
}
// 初始化地形拆分用的预制体信息
TerrainsSplit.Instance.InitPrefabsInfo(
ConfData.chunkData.StaticOnly, ConfData.chunkData.PrefabsExportDepthLimit);
ProgressBarUpdate(
"地形拆分成功", 1.0f);
// 到处此次地形拆分配置信息
TerrainsSettings.GetInstance().ExportBySceneName(CurSceneName);
ProgressBarClear();
// 刷新
AssetDatabase.Refresh();
}, Color.yellow);
}
}
}
/// <summary>
/// 新建地形
/// </summary>
/// <param name="iLevel">层级(影响到左边缩进的余白)</param>
private void NewTerrains(int iLevel)
{
var level = iLevel;
++level;
DrawLongLabel(level, "地形尺寸设定：");
++level;
{
DrawMiddleSlider(
level, "宽(X方向)：",
ref ConfData.tileData.TerrainSize.x,
128.0f, 1024.0f);
if (!UtilsTools.IsPowerOf2((int)ConfData.tileData.TerrainSize.x))
{
var error = string.Format("{0} 不是2的N次幂(2~16)！",
(int)ConfData.tileData.TerrainSize.x);
DrawLabel(level + 1, error, Color.red);
}
}
{
DrawMiddleSlider(
level, "长(Z方向)：",
ref ConfData.tileData.TerrainSize.z,
128.0f, 1024.0f);
if (!UtilsTools.IsPowerOf2((int)ConfData.tileData.TerrainSize.z))
{
var error = string.Format("{0} 不是2的N次幂(2~16)！",
(int)ConfData.tileData.TerrainSize.z);
DrawLabel(level + 1, error, Color.red);
}
}
{
DrawMiddleSlider(
level, "高(Y方向)：",
ref ConfData.tileData.TerrainSize.y,
128.0f, 1024.0f);
if (!UtilsTools.IsPowerOf2((int)ConfData.tileData.TerrainSize.y))
{
var error = string.Format("{0} 不是2的N次幂(2~16)！",
(int)ConfData.tileData.TerrainSize.y);
DrawLabel(level + 1, error, Color.red);
}
}
// 分界线
DrawLongLabel(0, "---------------");
--level;
// 地形数量
DrawLongLabel(level, "地形数量(布局)：");
++level;
DrawMiddleSlider(
level, "数量(x)：",
ref ConfData.TileSize.x,
1.0f, 16.0f);
DrawMiddleSlider(
level, "数量(z)：",
ref ConfData.TileSize.y,
1.0f, 16.0f);
// 基础地形
DrawMiddleTerrain(level, "基础地形：", ref ConfData.tileData.Data);
--level;
DrawSingleButton(0, "初始化地形",
delegate()
{
// 自动生成Chunk
AutoCreateTerrains(ConfData.tileData);
}, Color.yellow);
}
