Пример #1
0
        /// <summary>
        /// ラインブリードのチェックをする
        /// 
        /// --------------------------------------------------
        /// |        |             |    (あ)    | 父父父父   |
        /// |        |             |   父父父   +------------|
        /// |        |             |            | 父父父母   |
        /// |        |    父父     +------------+------------|
        /// |        |             |            | 父父母父   |
        /// |        |             |   父父母   +------------|
        /// |        |             |            | 父父母母   |
        /// | 父     |-------------+------------+------------|
        /// |        |             |    (い)    | 父母父父   |
        /// |        |             |   父母父   +------------|
        /// |        |             |            | 父母父母   |
        /// |        |    父母     +------------+------------|
        /// |        |             |            | 父母母父   |
        /// |        |             |   父母母   +------------|
        /// |        |             |            | 父母母母   |
        /// |--------+-------------+------------+------------|
        /// |        |             |    (う)    | 母父父父   |
        /// |        |             |   母父父   +------------|
        /// |        |             |            | 母父父母   |
        /// |        |    母父     +------------+------------|
        /// |        |             |            | 母父母父   |
        /// |        |             |   母父母   +------------|
        /// |        |             |            | 母父母母   |
        /// | 母     +-------------+------------+------------|
        /// |        |             |    (え)    | 母母父父   |
        /// |        |             |   母母父   +------------|
        /// |        |             |            | 母母父母   |
        /// |        |    母母     +------------+------------|
        /// |        |             |            | 母母母父   |
        /// |        |             |   母母母   +------------|
        /// |        |             |            | 母母母母   |
        /// --------------------------------------------------
        /// 
        /// 親系統ラインブリード4本爆発型(危険度1)
        /// 	3代目先祖の種牡馬4頭(あ・い・う・え)の親系統が全て同じで、
        /// 	子系統がすべて違う場合に成立します。
        /// 	父の特性がSPの場合は「親系統ラインブリード4本爆発SP型」になります。
        /// 	3代前の他の先祖馬がそれぞれ異なった親系統でないと、気性難や体質の弱化が起こる可能性 が高くなります。
        /// 
        /// 親系統ラインブリード3本爆発型(危険度1)
        /// 	3代目先祖の種牡馬4頭(あ・い・う・え)の うち、3頭の親系統が全て同じで、
        /// 	子系統がすべて違う場合に成立します。
        /// 	父の特性がSPの場合は「親系統ラインブリード3本爆発SP型」になります。
        /// 	3代前の他の先祖馬がそれぞれ異なった親系統でないと、気性難や体質の弱化が起こる可能性 が高くなります。
        /// 
        /// 親系統ラインブリード(危険度1)
        /// 	父母ともに、同じ親系統の場合成立します。
        /// 	父の特性がSPの場合は「親系統ラインブリードSP型」になります。3代前の祖先8頭のうち、
        /// 	親系統の種類が5より多いい場合は危険度が下がります。
        /// 
        /// 子系統ラインブリード(危険度2)
        /// 	父母ともに、同じ子系統の場合成立します。
        /// 	父の特性がSPの場合は「子系統ラインブリードSP型 」になります。
        /// 	3代前の祖先8頭のうち、親系統の種類が5より多いい場合は危険度が下がります。
        /// 
        ///		×父の特性がSPの場合は「子系統ラインブリードSP型 」になります。
        ///		○父と母の特性がSP型の場合は「子系統ラインブリードSP型 」になります。
        /// </summary>
        private void ラインブリードのチェック()
        {
            var target_blood_list = new List< Pedigree.Node >();

            // ラインブリード対象になる血統を取得
            foreach( var pedigree in new []{ this.SirePedigree, this.DamPedigree } ) {
                foreach( var node in pedigree.NodeList(2) ) {
                    if( node.Type == Enums.血統タイプ.父系 ) {
                        target_blood_list.Add( node );
                    }
                }
            }
            Debug.Assert( target_blood_list.Count == 4 );

            HBloodData
                blood1 = new HBloodData(),
                blood2 = new HBloodData(),
                blood3 = new HBloodData(),
                blood4 = new HBloodData();

            this.wp.HBloodTable.GetData( target_blood_list[0].BloodNum, ref blood1 );
            this.wp.HBloodTable.GetData( target_blood_list[1].BloodNum, ref blood2 );
            this.wp.HBloodTable.GetData( target_blood_list[2].BloodNum, ref blood3 );
            this.wp.HBloodTable.GetData( target_blood_list[3].BloodNum, ref blood4 );

            FamilyLineInfo
                child_line1  = this.family_line_info[ blood1.family_line_num ],
                child_line2  = this.family_line_info[ blood2.family_line_num ],
                child_line3  = this.family_line_info[ blood3.family_line_num ],
                child_line4  = this.family_line_info[ blood4.family_line_num ];

            // 出現率の1番多い親系統の数を数える
            var parent_line_match_count = 1;
            var info_ary = new []{ child_line1, child_line2, child_line3, child_line4, };

            for( var i=0; i<info_ary.Length; ++i ) {
                var temp = 1;
                for( var j=0; j<info_ary.Length; ++j ) {
                    if( i != j && info_ary[i].ParentFamilyLuneNum == info_ary[j].ParentFamilyLuneNum ) {
                        temp++;
                    }
                }
                if( temp > parent_line_match_count ) {
                    parent_line_match_count = temp;
                }
            }

            // 親系統ラインブリード爆発型のチェック
            if( parent_line_match_count >= 3 ) {
                // 子系統の種類を数える
                var child_num_ary = new UInt32[]{
                    blood1.family_line_num,
                    blood2.family_line_num,
                    blood3.family_line_num,
                    blood4.family_line_num,
                };
                // 重複カット
                child_num_ary = child_num_ary.Distinct().ToArray();

                if( parent_line_match_count == 4 && child_num_ary.Length == 4 ) {
                    if( child_line1.Data.family_line_attr == 1 ) {
                        this.Combination.ラインブリード = Enums.ラインブリード.親系統4本爆発SP型;
                    } else {
                        this.Combination.ラインブリード = Enums.ラインブリード.親系統4本爆発型;
                    }
                    return;
                }
                if( parent_line_match_count == 3 && child_num_ary.Length == 4 ) {
                    if( child_line1.Data.family_line_attr == 1 ) {
                        this.Combination.ラインブリード = Enums.ラインブリード.親系統3本爆発SP型;
                    } else {
                        this.Combination.ラインブリード = Enums.ラインブリード.親系統3本爆発型;
                    }
                    return;
                }
            }

            var father_family_line = this.family_line_info[ this.SirePedigree.Tree.Data.family_line_num ];
            var mother_family_line = this.family_line_info[ this.DamPedigree.Tree.Data.family_line_num ];

            // 子系統ラインブリードのチェック
            if( this.SirePedigree.Tree.Data.family_line_num == this.DamPedigree.Tree.Data.family_line_num ) {
                if( father_family_line.Data.family_line_attr == 1 ) {
                    this.Combination.ラインブリード = Enums.ラインブリード.子系統SP型;
                } else {
                    this.Combination.ラインブリード = Enums.ラインブリード.子系統;
                }
                return;
            }

            // 親系統ラインブリードのチェック
            // 資料とは少し違う
            if( father_family_line.ParentFamilyLuneNum == mother_family_line.ParentFamilyLuneNum ) {
                if( father_family_line.Data.family_line_attr == 1 && mother_family_line.Data.family_line_attr == 1 ) {
                    this.Combination.ラインブリード = Enums.ラインブリード.親系統SP型;
                } else {
                    this.Combination.ラインブリード = Enums.ラインブリード.親系統;
                }
                return;
            }
        }
Пример #2
0
        /// <summary>
        /// 血脈活性化配合のチェック
        /// 
        /// ---------------------------------------------------
        /// |        |             |  ※        | 父父父父    |
        /// |        |             |   父父父   +-------------|
        /// |        |             |            | 父父父母    |
        /// |        |    父父     +------------+-------------|
        /// |        |             |  ※        | 父父母父    |
        /// |        |             |   父父母   +-------------|
        /// |        |             |            | 父父母母    |
        /// | 父     |-------------+------------+-------------|
        /// |        |             |  ※        | 父母父父    |
        /// |        |             |   父母父   +-------------|
        /// |        |             |            | 父母父母    |
        /// |        |    父母     +------------+-------------|
        /// |        |             |  ※        | 父母母父    |
        /// |        |             |   父母母   +-------------|
        /// |        |             |            | 父母母母    |
        /// |--------+-------------+------------+-------------|
        /// |        |             |  ※        | 母父父父    |
        /// |        |             |   母父父   +-------------|
        /// |        |             |            | 母父父母    |
        /// |        |    母父     +------------+-------------|
        /// |        |             |  ※        | 母父母父    |
        /// |        |             |   母父母   +-------------|
        /// |        |             |            | 母父母母    |
        /// | 母     +-------------+------------+-------------|
        /// |        |             |  ※        | 母母父父    |
        /// |        |             |   母母父   +-------------|
        /// |        |             |            | 母母父母    |
        /// |        |    母母     +------------+-------------|
        /// |        |             |  ※        | 母母母父    |
        /// |        |             |   母母母   +-------------|
        /// |        |             |            | 母母母母    |
        /// ---------------------------------------------------
        /// 
        /// 3代前の先祖馬の親系統が6種類以上の場合成立する。
        /// 親系統の数に応じて爆発力がアップします。また同時にインブリードを成立させた場合、
        /// インブリードによるデメリットが少なくなります。
        /// (インブリードが3×4より薄い場合)7本型以上の場合はデメリットがなくなります。
        /// </summary>
        private void 血脈活性化配合のチェック()
        {
            var TARGET_LEN = 8;
            var activity_node_list = new Pedigree.Node[TARGET_LEN];
            var counter = 0;

            foreach( var pedigree in new []{ this.SirePedigree, this.DamPedigree } ) {
                foreach( var node in pedigree.NodeList(2) ) {
                    activity_node_list[ counter++ ] = node;
                }
            }
            Debug.Assert( counter == TARGET_LEN );

            var parent_family_line_list = new UInt32[TARGET_LEN];

            counter = 0;
            foreach( var node in activity_node_list ) {
                var family_line_info = this.family_line_info[ node.Data.family_line_num ];
                parent_family_line_list[ counter++ ] = family_line_info.ParentFamilyLuneNum;
            }

            var count = parent_family_line_list.Distinct().Count();

            switch( count ) {
            case 6:
                this.Combination.血脈活性化配合 = Enums.血脈活性化配合.六本型;
                break;
            case 7:
                this.Combination.血脈活性化配合 = Enums.血脈活性化配合.七本型;
                break;
            case 8:
                this.Combination.血脈活性化配合 = Enums.血脈活性化配合.八本型;
                break;
            default:
                this.Combination.血脈活性化配合 = Enums.血脈活性化配合.無し;
                break;
            }
        }