예제 #1
0
        //根据城市总数,随机城市
        private void CreateCities()
        {
            GameObject cityNode = GameObject.FindGameObjectWithTag(EGameConstL.TAG_CITY_NODE);

            if (!cityNode || !m_cityModel)
            {
                EUtilityHelperL.LogError("None city node or model!");
                return;
            }

            //生成预定数量的城市
            for (int i = 0; i < m_citiesCount; ++i)
            {
                City clone = Instantiate <City>(m_cityModel);
                clone.name     = string.Format("City_{0}", i);
                clone.UnitName = clone.name;

                clone.transform.SetParent(cityNode.transform);
                clone.transform.localPosition = GetCityPos();
                clone.transform.localScale    = Vector3.one;
                clone.transform.localRotation = Quaternion.identity;
                clone.transform.gameObject.SetActive(true);

                //初始化城市
                clone.Init();
            }
        }
예제 #2
0
        //***********************************************

        private GridUnit GetGridClicked(Vector3 clickedWorldPos)
        {
            //转换空间到格子组织节点(GridUnits)的空间
            clickedWorldPos = gridUnitsRoot.transform.InverseTransformPoint(clickedWorldPos);
            //初步判定所在行列
            int row    = Mathf.FloorToInt((clickedWorldPos.y - EGameConstL.Map_GridOffsetY * 0.5f) / -EGameConstL.Map_GridOffsetY);
            int column = Mathf.FloorToInt((clickedWorldPos.x + EGameConstL.Map_GridWidth * 0.5f - ((row & 1) == (EGameConstL.Map_FirstRowOffset ? 1 : 0) ? 0f : (EGameConstL.Map_GridWidth * 0.5f))) / EGameConstL.Map_GridWidth);

            int testRow    = 0;
            int testColumn = 0;
            //二次判定,判定周围格子
            GridUnit clickedGrid = null;
            float    minDis      = Mathf.Infinity;

            for (int r = -1; r <= 1; ++r)
            {
                for (int c = -1; c <= 1; ++c)
                {
                    testRow    = row + r;
                    testColumn = column + c;
                    if (testRow < 0 || testRow >= currentData.mapData.mapHeight ||
                        testColumn < 0 || testColumn >= currentData.mapData.mapWidth)
                    {
                        continue;
                    }
                    float distance = EUtilityHelperL.CalcDistanceInXYAxis(clickedWorldPos, currentData.mapData.mapGrids[testColumn, testRow].localPosition);
                    if (distance < minDis && distance < EGameConstL.Map_HexRadius)
                    {
                        minDis      = distance;
                        clickedGrid = gridUnits[testColumn, testRow];
                    }
                }
            }
            return(clickedGrid);
        }
예제 #3
0
        private void CreateHero()
        {
            GameObject m_heroNode = GameObject.FindGameObjectWithTag(EGameConstL.TAG_HERO_NODE);

            if (!m_heroModel || !m_heroNode)
            {
                return;
            }

            if (m_allFields.Count == 0)
            {
                EUtilityHelperL.LogWarning("请先创建野外");
                return;
            }

            Hero clone = Instantiate <Hero>(m_heroModel);

            if (clone)
            {
                clone.name = string.Format("Hero_{0}", m_allHeros.Count);
                clone.transform.SetParent(m_heroNode.transform);
                m_allHeros.Add(clone);
                //在城市位置出生
                int     randIdx = Random.Range(0, m_allCities.Count);
                Vector3 pos     = m_allCities[randIdx].transform.position;
                pos.y = 1.51f;
                clone.transform.position = pos;
                clone.gameObject.SetActive(true);
                //初始化
                clone.Init();
                clone.AddExp(Random.Range(0, 50));
            }
        }
예제 #4
0
        //准备加载战场
        private void PrepareBattleMap()
        {
            if (currentData == null)
            {
                EUtilityHelperL.LogError("Prepare battle map failed. No battle data.");
                return;
            }
            gridUnits = new GridUnit[currentData.mapData.mapWidth, currentData.mapData.mapHeight];

            for (int r = 0; r < currentData.mapData.mapHeight; ++r)
            {
                for (int c = 0; c < currentData.mapData.mapWidth; ++c)
                {
                    GridUnitData gud = currentData.mapData.mapGrids[c, r];
                    if (gud != null)
                    {
                        //创建一个用于显示的格子对象
                        GridUnit gridUnit = CreateGrid();
                        if (gridUnit != null)
                        {
                            gridUnits[c, r] = gridUnit;
                            gridUnit.transform.localPosition = gud.localPosition;
                            gridUnit.name     = string.Format("Grid_{0}_{1}", r, c);
                            gridUnit.gridData = gud;
                            gridUnit.RefreshColor();
                            gridUnit.gameObject.SetActive(true);
                        }
                    }
                }
            }
        }
예제 #5
0
        //准备加载战场
        private void PrepareBattleMap()
        {
            if (currentData == null)
            {
                EUtilityHelperL.LogError("Prepare battle map failed. No battle data.");
                return;
            }
            gridUnits = new GridUnit[currentData.mapWidth, currentData.mapHeight];

            for (int row = 0; row < currentData.mapHeight; ++row)
            {
                for (int column = 0; column < currentData.mapWidth; ++column)
                {
                    GridUnitData gud = currentData.mapGrids[column, row];
                    if (gud != null)
                    {
                        //创建一个用于显示的格子对象
                        GridUnit gu = CreateGrid();
                        if (gu != null)
                        {
                            gridUnits[column, row]     = gu;
                            gu.transform.localPosition = gud.localPosition;
                            gu.name     = string.Format("Grid_{0}_{1}", row, column);
                            gu.gridData = gud;
                            gu.Refresh();
                            gu.gameObject.SetActive(true);
                        }
                    }
                }
            }
        }
예제 #6
0
        private void Init()
        {
            if (inited)
            {
                return;
            }



            inited = true;
            EUtilityHelperL.Log("Battle creator inited.");
        }
예제 #7
0
        //拷贝文件夹
        public static void CopyFolder(string _from, string _to)
        {
            // EUtilityHelperL.Log(string.Format("拷贝文件:从{0}到{1}", _from, _to));
            if (Directory.Exists(_from) == false)
            {
                EUtilityHelperL.LogError("拷贝文件失败:文件不存在(" + _from + ")");
                return;
            }

            if (Directory.Exists(_to) == false)
            {
                // EUtilityHelperL.Log(_to + "文件不存在,新建");
                Directory.CreateDirectory(_to);
            }

            //TODO:先这么写吧,能用就行,有机会再完善
            //拷贝.txt, .lua, .json
            string[] paths = Directory.GetFiles(_from, "*.*", SearchOption.TopDirectoryOnly);
            for (int i = 0; i < paths.Length; ++i)
            {
                paths[i] = paths[i].Replace('\\', '/');
                string fileName = paths[i].Remove(0, paths[i].LastIndexOf("/") + 1);
                File.Copy(paths[i], _to + "/" + fileName, true);
            }
            //            paths = Directory.GetFiles(_from, "*.json", SearchOption.TopDirectoryOnly);
            //            for(int i = 0; i < paths.Length; ++i)
            //            {
            //                paths[i] = paths[i].Replace('\\','/');
            //                string fileName = paths[i].Remove(0, paths[i].LastIndexOf("/") + 1);
            //                File.Copy(paths[i], _to + "/" + fileName, true);
            //            }
            //            paths = Directory.GetFiles(_from, "*.txt", SearchOption.TopDirectoryOnly);
            //            for(int i = 0; i < paths.Length; ++i)
            //            {
            //                paths[i] = paths[i].Replace('\\','/');
            //                string fileName = paths[i].Remove(0, paths[i].LastIndexOf("/") + 1);
            //                File.Copy(paths[i], _to + "/" + fileName, true);
            //            }

            //拷贝文件夹
            string[] folderPaths = Directory.GetDirectories(_from, "*", SearchOption.TopDirectoryOnly);
            for (int i = 0; i < folderPaths.Length; ++i)
            {
                folderPaths[i] = folderPaths[i].Replace('\\', '/');
                string folderName = folderPaths[i].Remove(0, folderPaths[i].LastIndexOf("/") + 1);
                //递归拷贝
                CopyFolder(folderPaths[i], _to + "/" + folderName);
            }
        }
예제 #8
0
        /// <summary>
        /// //计算英雄探索某一野外的收益
        /// </summary>
        /// <param name="heroData">英雄数据</param>
        /// <param name="heroPos">英雄位置</param>
        /// <param name="fieldData">野外数据</param>
        /// <param name="fieldPos">野外位置</param>
        /// <returns></returns>
        public float Calculate(HeroData heroData, Vector3 heroPos, FieldData fieldData, Vector3 fieldPos)
        {
            //收益
            //经验 + 金钱 + 声望
            float exp  = CalculateExp(heroData, fieldData, fieldData.resRemain);
            float gold = CalculateGold(heroData, fieldData, fieldData.resRemain);
            float fame = CalculateFame(heroData, fieldData, fieldData.resRemain);

            //时间
            float time = CalculateExploreTime(heroData, fieldData, fieldData.resRemain);
            //路途时间
            float travelTime = EUtilityHelperL.CalcDistanceIn2D(heroPos, fieldPos) / heroData.moveSpeed;

            return((exp + gold + fame) / (time + travelTime + Mathf.Epsilon));
        }
예제 #9
0
        //获取文件名字
        public static string GetFileName(string _path, bool hideBack = true)
        {
            int start = _path.LastIndexOf('/');

            if (start >= 0)
            {
                string _temp = _path.Remove(0, start + 1);
                int    end   = _temp.IndexOf('.');
                if (end >= 0 && hideBack)
                {
                    return(_temp.Remove(end));
                }
            }
            EUtilityHelperL.LogError("获取文件名称失败");
            return("");
        }
예제 #10
0
파일: City.cs 프로젝트: lykyyy/HalfWorld
        public override void Init(params object[] args)
        {
            if (m_inited)
            {
                return;
            }

            if (!m_fieldModel)
            {
                EUtilityHelperL.LogError("City unit error: none file model");
                return;
            }

            //向世界管理器注册
            WorldManager.Instance.OperateCity(this, true);

            m_inited = true;
        }
예제 #11
0
        public BattleMapData CreateMap(int width, int height, int obstacleCount, int obstacleGap)
        {
            BattleMapData battleMapData = null;
            int           mapID         = 0;

            base.Create(out battleMapData, out mapID);
            if (battleMapData != null)
            {
                battleMapData.mapID = mapID;
                battleMapData.Generate(width, height, obstacleCount, obstacleGap);
            }
            else
            {
                EUtilityHelperL.LogError(string.Format("Create map failed->width:{0},height:{1}",
                                                       width, height));
            }
            return(battleMapData);
        }
예제 #12
0
        //获取一个随机的野外位置
        private Vector3 GetFieldPos(Transform city)
        {
            Vector3 randPos = Vector3.zero;
            //每次随机查找位置可以随机的机会,越大则越可能让世界摆放的相对分散,计算时间也越长
            int chance = randomChance;
            //是否找到了合适的位置
            bool             findOut = false;
            List <Transform> temp    = null;

            m_fieldClonesAroundCity.TryGetValue(city, out temp);
            while (chance > 0 && !findOut)
            {
                findOut = true;
                --chance;
                //在m_cityRadiusRange.x ~ m_cityRadiusRange.y半径范围内随机一个位置
                //注意这里随机的位置是相对于当前city空间的
                var randV2 = Random.insideUnitCircle.normalized * Random.Range(m_cityRadiusRange.x, m_cityRadiusRange.y);
                randPos.x = randV2.x;
                randPos.z = randV2.y;
                if (temp != null)
                {
                    //计算与其他野外的位置关系
                    foreach (var item in temp)
                    {
                        //距离有点近呢
                        //需要将空间位置进行一次转换
                        if (EUtilityHelperL.CalcDistanceIn2D(city.InverseTransformPoint(item.transform.position), randPos) < m_fieldDensity)
                        {
                            findOut = false;
                            break;
                        }
                    }
                }
            }

            //提醒一下
            if (!findOut)
            {
                Debug.LogWarning("没有找到合适的野外位置,凑合一下吧~");
            }

            return(randPos);
        }
예제 #13
0
파일: City.cs 프로젝트: lykyyy/HalfWorld
        /// <summary>
        /// 获得随机的野外位置
        /// </summary>
        /// <param name="density">密度系数</param>
        /// <param name="minRadius">最小半径</param>
        /// <param name="maxRadius">最大半径</param>
        /// <returns></returns>
        private Vector3 GetFieldPos(float density, float minRadius, float maxRadius)
        {
            Vector3 randPos = Vector3.zero;
            //每次随机查找位置可以随机的机会,越大则越可能让世界摆放的相对分散,计算时间也越长
            int chance = EGameConstL.FIELD_RAND_CHANCE;

            //是否找到了合适的位置
            bool findOut = false;

            while (chance > 0 && !findOut)
            {
                findOut = true;
                --chance;
                //在m_cityRadiusRange.x ~ m_cityRadiusRange.y半径范围内随机一个位置
                //注意这里随机的位置是相对于当前city空间的
                var randV2 = Random.insideUnitCircle.normalized * Random.Range(minRadius, maxRadius);

                randPos.x = randV2.x;
                randPos.z = randV2.y;

                //计算与其他野外的位置关系
                foreach (var item in m_roundFields)
                {
                    //距离有点近呢
                    //需要将空间位置进行一次转换
                    if (EUtilityHelperL.CalcDistanceIn2D(transform.InverseTransformPoint(item.transform.position), randPos) < density)
                    {
                        findOut = false;
                        break;
                    }
                }
            }

            //提醒一下
            if (!findOut)
            {
                Debug.LogWarning("Can not find out optimum random position for field...");
            }

            return(randPos);
        }
예제 #14
0
        //战场中铺设格子
        public void Generate(int width, int height, int obstacleCount, int gap)
        {
            EUtilityHelperL.TimerStart();

            if (width <= 0 || height <= 0)
            {
                return;
            }

            //记录地图宽高
            mapWidth  = width;
            mapHeight = height;
            //生成格子数组
            mapGrids = new GridUnitData[mapWidth, mapHeight];

            //全部生成为普通格子
            for (int r = 0; r < mapHeight; ++r)
            {
                for (int c = 0; c < mapWidth; ++c)
                {
                    GridUnitData gridUnitData = new GridUnitData(mapID, r, c);
                    gridUnitData.localPosition = new Vector3(
                        c * EGameConstL.Map_GridWidth + ((r & 1) == (EGameConstL.Map_FirstRowOffset ? 0 : 1) ? (EGameConstL.Map_GridWidth * 0.5f) : 0f),
                        -r * EGameConstL.Map_GridOffsetY,
                        0
                        );

                    //初始设置为普通格子
                    gridUnitData.GridType = GridType.Normal;
                    //保存
                    mapGrids[c, r] = gridUnitData;
                }
            }
            //随机一些障碍格子
            GenerateObstacle(obstacleCount, gap);
            //整理格子列表
            TidyGridList();

            EUtilityHelperL.Log(string.Format("Generate map {0}, time cost:{1}", mapID, EUtilityHelperL.TimerEnd()));
        }
예제 #15
0
파일: Hero.cs 프로젝트: elsong823/HalfWorld
        //选择城市
        void SearchCity()
        {
            float dis     = Mathf.Infinity;
            float tempDis = 0f;
            City  target  = null;
            var   citys   = WorldManager.Instance.AllCities;

            while (citys.MoveNext())
            {
                tempDis = EUtilityHelperL.CalcDistanceIn2D_SQR(citys.Current.transform.position, transform.position);
                if (tempDis < dis)
                {
                    target = citys.Current;
                    dis    = tempDis;
                }
            }

            if (target)
            {
                m_cityTarget = target;
                State        = HeroState.Move;
            }
        }
예제 #16
0
파일: City.cs 프로젝트: lykyyy/HalfWorld
        /// <summary>
        /// 创建野外
        /// </summary>
        /// <param name="count">创建数量</param>
        /// <param name="density">密度系数</param>
        /// <param name="minRadius">最小半径</param>
        /// <param name="maxRadius">最大半径</param>
        public void CreateFields(int count, float density, float minRadius, float maxRadius)
        {
            GameObject fieldNode = GameObject.FindGameObjectWithTag(EGameConstL.TAG_FIELD_NODE);

            if (!fieldNode || !m_fieldModel)
            {
                EUtilityHelperL.LogError("None filed node or model!");
                return;
            }

            int created = 0;

            //生成预定数量的野外
            for (int i = 0; i < count; ++i)
            {
                Field clone = Instantiate <Field>(m_fieldModel);
                clone.transform.SetParent(fieldNode.transform);

                //设置名字
                clone.name     = string.Format("Field_{0}_{1}", m_roundFields.Count, UnitName);
                clone.UnitName = clone.name;

                //设置所属城市
                clone.CityUnit = this;

                //必须要做的转换
                clone.transform.position      = transform.TransformPoint(GetFieldPos(density, minRadius, maxRadius));
                clone.transform.localScale    = Vector3.one;
                clone.transform.localRotation = Quaternion.identity;
                clone.gameObject.SetActive(true);
                m_roundFields.Add(clone);

                clone.Init();

                ++created;
            }
        }
예제 #17
0
        //计算声望获取倍数
        public float CalculateFameMultiple(HeroData heroData, FieldData fieldData)
        {
            int needLevel = 1;

            if (!fieldDiff.ContainsKey(fieldData.difficulty))
            {
                EUtilityHelperL.LogWarning("错误的野外难度!");
            }
            else
            {
                needLevel = Mathf.FloorToInt(fieldDiff[fieldData.difficulty].key);
            }
            //等级差距
            float lvGap = heroData.level - needLevel;

            for (int i = 0; i < ladderFame.Length; ++i)
            {
                if (lvGap <= ladderFame[i].key)
                {
                    return(ladderFame[i].value);
                }
            }
            return(ladderFame[ladderFame.Length - 1].value);
        }
예제 #18
0
        //计算探索速度
        public float CalculateExploreTimeMultiple(HeroData heroData, FieldData fieldData)
        {
            float strNeed = Mathf.Infinity;

            if (fieldDiff.ContainsKey(fieldData.difficulty))
            {
                strNeed = fieldDiff[fieldData.difficulty].value;
            }
            else
            {
                EUtilityHelperL.LogError("错误的野外难度等级");
            }
            //计算力量差距
            int gap = Mathf.FloorToInt((heroData.strength - strNeed) / strNeed * 100f);

            for (int i = 0; i < ladderTime.Length; ++i)
            {
                if (gap <= ladderTime[i].key)
                {
                    return(ladderTime[i].value);
                }
            }
            return(ladderTime[ladderTime.Length - 1].value);
        }
예제 #19
0
        //获取一个随机的城市位置
        private Vector3 GetCityPos()
        {
            Vector3 randPos = new Vector3(0f, 1.01f, 0f);

            //每次随机查找位置可以随机的机会,越大则越可能让世界摆放的相对分散,计算时间也越长
            int chance = EGameConstL.CITY_RAND_CHANCE;
            //是否找到了合适的位置
            bool findOut = false;

            while (chance > 0 && !findOut)
            {
                findOut = true;
                --chance;
                //随机一个位置
                randPos.x = Random.Range(-m_mapSize.x * 0.5f, m_mapSize.x * 0.5f);
                randPos.z = Random.Range(-m_mapSize.y * 0.5f, m_mapSize.y * 0.5f);
                //计算与其他城市间的位置关系
                foreach (var item in m_allCities)
                {
                    //距离有点近呢
                    if (EUtilityHelperL.CalcDistanceIn2D(item.transform.localPosition, randPos) < m_cityDensity)
                    {
                        findOut = false;
                        break;
                    }
                }
            }

            //提醒一下
            if (!findOut)
            {
                Debug.LogWarning("Can not find out optimum random position for city...");
            }

            return(randPos);
        }
예제 #20
0
        //放置一些障碍格子
        private void DisposeGridUnits(int obstacle, int gap)
        {
            obstacle = Mathf.Min(mapWidth * mapHeight, obstacle);

            for (int i = 0; i < obstacle; ++i)
            {
                int          randomIdx = -1;
                GridUnitData target    = null;
                int          tryTimes  = 999;
                while (tryTimes > 0 && target == null)
                {
                    randomIdx = Random.Range(0, normalGrids.Count);
                    target    = normalGrids[randomIdx];
                    //判断距离
                    for (int j = 0; j < obstacleGrids.Count; ++j)
                    {
                        var distance = obstacleGrids[j].Distance(target);
                        if (obstacleGrids[j].Distance(target) < gap)
                        {
                            target = null;
                            break;
                        }
                    }
                    --tryTimes;
                }
                if (target != null)
                {
                    SetGridType(target, GridType.Obstacle);
                    normalGrids.RemoveAt(randomIdx);
                }
                else
                {
                    EUtilityHelperL.LogWarning("Dispose grid unit data warning.");
                }
            }
        }
예제 #21
0
 public void Init(params object[] args)
 {
     EUtilityHelperL.Log("Battle map manager inited.");
 }
예제 #22
0
        private void TestNavigation()
        {
            //如果点击了鼠标左键
            if (Input.GetMouseButtonDown(0))
            {
                //计算点击位置
                Vector3 clickedWorldPos = BattleCamera.ScreenToWorldPoint(Input.mousePosition);
                clickedWorldPos.z = 0;
                //判断是否有格子被点中?
                GridUnit clicked = GetGridClicked(clickedWorldPos);
                //点中了格子
                if (clicked != null)
                {
                    if (clicked.gridData.GridType == GridType.Obstacle)
                    {
                        //点中了障碍物!
                        Debug.Log("Clicked obstacle.");
                        return;
                    }
                    if (from == null)
                    {
                        //当前还没有选择起始地点
                        from = clicked;
                        from.GridRenderType = GridRenderType.Start;
                    }
                    else if (to == null)
                    {
                        //两次点中了起点
                        if (from.Equals(clicked))
                        {
                            return;
                        }

                        //当前没有选择终点
                        to = clicked;
                        to.GridRenderType = GridRenderType.End;
                        EUtilityHelperL.TimerStart();
                        int navTimes = 999;
                        int count    = navTimes;
                        while (count > 0)
                        {
                            //有起点有终点,开始导航
                            if (MapNavigator.Instance.Navigate(currentData.mapData, from.gridData, to.gridData, path, searched))
                            {
                            }
                            else
                            {
                                //没有找到路径
                                Debug.LogError("Navitation failed. No path.");
                                return;
                            }
                            --count;
                        }
                        TestGridRender();
                        EUtilityHelperL.Log(string.Format("Nav times:{0}, timeCost{1:00}", navTimes, EUtilityHelperL.TimerEnd()));
                    }
                    else
                    {
                        from.GridRenderType = GridRenderType.Normal;
                        from = null;
                        to.GridRenderType = GridRenderType.Normal;
                        to = null;
                        foreach (var item in searched)
                        {
                            gridUnits[item.column, item.row].GridRenderType = GridRenderType.Normal;
                        }

                        foreach (var item in path)
                        {
                            gridUnits[item.column, item.row].GridRenderType = GridRenderType.Normal;
                        }
                    }
                }
                //没有点中格子
                else
                {
                    if (from != null)
                    {
                        from.GridRenderType = GridRenderType.Normal;
                        from = null;
                    }
                    if (to != null)
                    {
                        to.GridRenderType = GridRenderType.Normal;
                        to = null;
                    }

                    foreach (var item in searched)
                    {
                        gridUnits[item.column, item.row].GridRenderType = GridRenderType.Normal;
                    }

                    foreach (var item in path)
                    {
                        gridUnits[item.column, item.row].GridRenderType = GridRenderType.Normal;
                    }
                }
            }
        }