private void CheckTamHinhTheoChi(ChiEnum chi1, ChiEnum chi2, ChiEnum chi3)
{
var chi1Id = this.TuTru.FindIndex(u => u.DiaChi.Ten == chi1);
var chi2Id = this.TuTru.FindIndex(u => u.DiaChi.Ten == chi2);
var chi3Id = this.TuTru.FindIndex(u => u.DiaChi.Ten == chi3);
if (chi1Id != -1 && chi2Id != -1 && chi3Id != -1)
{
var dc1 = this.TuTru[chi1Id].DiaChi;
var dc2 = this.TuTru[chi2Id].DiaChi;
var dc3 = this.TuTru[chi3Id].DiaChi;
var dantythan = new List <ChiEnum> {
ChiEnum.Dan, ChiEnum.Ty, ChiEnum.Than
};
var suutuatmui = new List <ChiEnum> {
ChiEnum.Suu, ChiEnum.Tuat, ChiEnum.Mui
};
if (dantythan.Contains(chi1))
{
dc1.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.DAN_TY_THAN);
dc2.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.DAN_TY_THAN);
dc3.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.DAN_TY_THAN);
}
else if (suutuatmui.Contains(chi1))
{
dc1.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.SUU_TUAT_MUI);
dc2.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.SUU_TUAT_MUI);
dc3.AddThuocTinh(Constants.ThuocTinh.TAM_HINH, Constants.DiaChiTuongHinh.SUU_TUAT_MUI);
}
}
}
public DiaChi(ChiEnum chi, ThienCan bankhi, ThienCan trungkhi, ThienCan tapkhi) : base()
{
this.Ten = chi;
this.BanKhi = bankhi;
this.TrungKhi = trungkhi;
this.TapKhi = tapkhi;
}
/// <summary>
/// NguThuDon: Find the correct Tru with Can and Chi
/// </summary>
/// <param name="canNgay">Finding is based on canNgay</param>
/// <param name="chiToBeFound">to-be-found chi</param>
/// <returns>Tru with Can and Chi</returns>
public static Tru NguThuDon(CanEnum canNgay, ChiEnum chiToBeFound)
{
CanEnum canStart = CanEnum.None;
ChiEnum chiStart = ChiEnum.Ti;
switch (canNgay)
{
case CanEnum.None:
break;
case CanEnum.Giap:
case CanEnum.Ky:
canStart = CanEnum.Giap;
break;
case CanEnum.At:
case CanEnum.Canh:
canStart = CanEnum.Binh;
break;
case CanEnum.Binh:
case CanEnum.Tan:
canStart = CanEnum.Mau;
break;
case CanEnum.Dinh:
case CanEnum.Nham:
canStart = CanEnum.Canh;
break;
case CanEnum.Mau:
case CanEnum.Quy:
canStart = CanEnum.Nham;
break;
default:
break;
}
int nChi = TongHopCanChi.MuoiHaiDiaChi.Count;
int chiStartIndex = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == chiStart);
int chiDestIndex = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == chiToBeFound);
int steps = (chiDestIndex - chiStartIndex + nChi) % nChi;
int canStartIndex = TongHopCanChi.MuoiThienCan.FindIndex(u => u.Can == canStart);
int nCan = TongHopCanChi.MuoiThienCan.Count;
int canDestIndex = (canStartIndex + steps) % nCan;
var thienCan = TongHopCanChi.MuoiThienCan[canDestIndex];
var diaChi = TongHopCanChi.MuoiHaiDiaChi[chiDestIndex];
return(new Tru(thienCan, diaChi));
}
private void SetThanSatTru(CanEnum can, ChiEnum chi, string thansat)
{
TruCollection law = new TruCollection(this.TTM);
foreach (var item in law.TatcaTru)
{
if (item.ThienCan.Can == can && item.DiaChi.Ten == chi)
{
item.AddThanSat(thansat);
}
}
}
private void CheckTamHop(ChiEnum chi1, ChiEnum chi2, ChiEnum chi3)
{
int count = 0;
DiaChi dc1 = null, dc2 = null, dc3 = null;
var chi1Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi1);
var chi2Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi2);
var chi3Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi3);
if (chi1Id != -1)
{
count++;
dc1 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi1);
}
if (chi2Id != -1)
{
count++;
dc2 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi2);
}
if (chi3Id != -1)
{
count++;
dc3 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi3);
}
string thuocTinh = string.Empty;
if (count == 2)
{
thuocTinh = Constants.ThuocTinh.BAN_TAM_HOP;
}
if (count == 3)
{
thuocTinh = Constants.ThuocTinh.TAM_HOP;
}
if (dc1 != null)
{
this.SetThuocTinh(dc1, thuocTinh);
}
if (dc2 != null)
{
this.SetThuocTinh(dc2, thuocTinh);
}
if (dc3 != null)
{
this.SetThuocTinh(dc3, thuocTinh);
}
}
private void CoThanQuaTu()
{
var chiNam = this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NAM].DiaChi.Ten;
ChiEnum co = ChiEnum.None, qua = ChiEnum.None;
switch (chiNam)
{
case ChiEnum.None:
break;
case ChiEnum.Hoi:
case ChiEnum.Ti:
case ChiEnum.Suu:
co = ChiEnum.Dan;
qua = ChiEnum.Tuat;
break;
case ChiEnum.Dan:
case ChiEnum.Mao:
case ChiEnum.Thin:
co = ChiEnum.Ty;
qua = ChiEnum.Suu;
break;
case ChiEnum.Ty:
case ChiEnum.Ngo:
case ChiEnum.Mui:
co = ChiEnum.Than;
qua = ChiEnum.Thin;
break;
case ChiEnum.Than:
case ChiEnum.Dau:
case ChiEnum.Tuat:
co = ChiEnum.Hoi;
qua = ChiEnum.Mui;
break;
default:
break;
}
if (co != ChiEnum.None)
{
TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == co).AddThanSat(Constants.ThanSat.CO_THAN);
}
if (qua != ChiEnum.None)
{
TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == qua).AddThanSat(Constants.ThanSat.QUA_TU);
}
}
private void CheckTuHinhTheoChi(ChiEnum chi)
{
for (int i = 0; i < this.TuTru.Count - 1; i++)
{
var currTru = this.TuTru[i];
var nextTru = this.TuTru[i + 1];
if (currTru.DiaChi.Ten == chi && nextTru.DiaChi.Ten == chi)
{
//Tu Hinh se la thuoc tinh cua Tru.
//This is a work-around.
currTru.AddThuocTinh(Constants.ThuocTinh.TU_HINH, Constants.DiaChiTuongHinh.TU_HINH);
nextTru.AddThuocTinh(Constants.ThuocTinh.TU_HINH, Constants.DiaChiTuongHinh.TU_HINH);
}
}
}
private void TaiSat()
{
ChiEnum nam = this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NAM].DiaChi.Ten;
ChiEnum taisat = ChiEnum.None;
switch (nam)
{
case ChiEnum.None:
break;
case ChiEnum.Dan:
case ChiEnum.Ngo:
case ChiEnum.Tuat:
taisat = ChiEnum.Ti;
break;
case ChiEnum.Ty:
case ChiEnum.Dau:
case ChiEnum.Suu:
taisat = ChiEnum.Mao;
break;
case ChiEnum.Than:
case ChiEnum.Ti:
case ChiEnum.Thin:
taisat = ChiEnum.Ngo;
break;
case ChiEnum.Hoi:
case ChiEnum.Mao:
case ChiEnum.Mui:
taisat = ChiEnum.Dau;
break;
default:
break;
}
if (taisat != ChiEnum.None)
{
TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == taisat).AddThanSat(Constants.ThanSat.TAI_SAT);
}
}
private void HocDuong()
{
CanEnum ngay = this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NGAY].ThienCan.Can;
ChiEnum chi = ChiEnum.None;
switch (ngay)
{
case CanEnum.None:
break;
case CanEnum.Giap:
case CanEnum.At:
chi = ChiEnum.Hoi;
break;
case CanEnum.Binh:
case CanEnum.Dinh:
case CanEnum.Mau:
case CanEnum.Ky:
chi = ChiEnum.Dan;
break;
case CanEnum.Canh:
case CanEnum.Tan:
chi = ChiEnum.Ty;
break;
case CanEnum.Nham:
case CanEnum.Quy:
chi = ChiEnum.Than;
break;
default:
break;
}
if (chi != ChiEnum.None)
{
TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi).AddThanSat(Constants.ThanSat.HOC_DUONG);
}
}
private void KimThan()
{
List <Tru> ngayGio = new List <Tru>
{
this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NGAY],
this.TTM.LaSoCuaToi.TuTru[Constants.TRU_GIO]
};
foreach (var tru in ngayGio)
{
CanEnum can = tru.ThienCan.Can;
ChiEnum chi = tru.DiaChi.Ten;
if ((can == CanEnum.Tan && chi == ChiEnum.Ty) ||
(can == CanEnum.Quy && chi == ChiEnum.Dau) ||
(can == CanEnum.At && chi == ChiEnum.Suu))
{
tru.AddThanSat(Constants.ThanSat.KIM_THAN);
}
}
}
private void NguyenThan()
{
ChiEnum nam = this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NAM].DiaChi.Ten;
var amDuong = this.TTM.LaSoCuaToi.TuTru[Constants.TRU_NAM].ThienCan.AmDuong;
var gioi = this.TTM.LaSoCuaToi.GioiTinh;
int namId = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == nam);
int n = TongHopCanChi.MuoiHaiDiaChi.Count;
int nguyenthanId = -1;
if ((gioi == GioiTinhEnum.Nam && amDuong == AmDuongEnum.Duong) ||
(gioi == GioiTinhEnum.Nu && amDuong == AmDuongEnum.Am))
{
nguyenthanId = (namId + 7) % n;
}
else
{
nguyenthanId = (namId + 5) % n;
}
TongHopCanChi.MuoiHaiDiaChi[nguyenthanId].AddThanSat(Constants.ThanSat.NGUYEN_THAN);
}
/// <summary>
/// Return the phase of Vong Truong Sinh given "can ngay" and "chi can tim"
/// </summary>
/// <param name="canNgay">"can ngay"</param>
/// <param name="chi">"chi can tim"</param>
/// <returns></returns>
public static GiaiDoanTruongSinhEnum VongTruongSinh(CanEnum canNgay, ChiEnum chi)
{
int direction = 1; //1: forward, -1: backward
int start = 0;
switch (canNgay)
{
case CanEnum.None:
break;
case CanEnum.Giap:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Hoi); //11; //Hoi
direction = 1;
break;
case CanEnum.At:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Ngo); //6; //Ngo
direction = -1;
break;
case CanEnum.Binh:
case CanEnum.Mau:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Dan); //2; //Dan
direction = 1;
break;
case CanEnum.Dinh:
case CanEnum.Ky:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Dau); //9; //Dau
direction = -1;
break;
case CanEnum.Canh:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Ty); //5; //Ty
direction = 1;
break;
case CanEnum.Tan:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Ti); //0; //Ti
direction = -1;
break;
case CanEnum.Nham:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Than); //8; //Than
direction = 1;
break;
case CanEnum.Quy:
start = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == ChiEnum.Mao); //3; //Mao
direction = -1;
break;
default:
break;
}
int dest = TongHopCanChi.MuoiHaiDiaChi.FindIndex(u => u.Ten == chi);
int n = TongHopCanChi.MuoiHaiDiaChi.Count;
int steps = (direction * (dest - start) + n) % n;
return((GiaiDoanTruongSinhEnum)(steps + 1)); //GiaiDoanTruongSinh starts with 1
}
private void CheckLucXung(ChiEnum chi1, ChiEnum chi2)
{
var chi1Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi1);
var chi2Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi2);
if (chi1Id != -1 && chi2Id != -1)
{
var diaChi1 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi1);
var diaChi2 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi2);
string thuocTinh = Constants.ThuocTinh.LUC_XUNG;
var lucXung = string.Empty;
var tiNgo = new List <ChiEnum> {
ChiEnum.Ti, ChiEnum.Ngo
};
var suuMui = new List <ChiEnum> {
ChiEnum.Suu, ChiEnum.Mui
};
var danThan = new List <ChiEnum> {
ChiEnum.Dan, ChiEnum.Than
};
var maoDau = new List <ChiEnum> {
ChiEnum.Mao, ChiEnum.Dau
};
var thinTuat = new List <ChiEnum> {
ChiEnum.Thin, ChiEnum.Tuat
};
var tyHoi = new List <ChiEnum> {
ChiEnum.Ty, ChiEnum.Hoi
};
if (tiNgo.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.TI_NGO;
}
else if (suuMui.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.SUU_MUI;
}
else if (danThan.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.DAN_THAN;
}
else if (maoDau.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.MAO_DAU;
}
else if (thinTuat.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.THIN_TUAT;
}
else if (tyHoi.Contains(chi1))
{
lucXung = Constants.DiaChiLucXung.TY_HOI;
}
diaChi1.AddThuocTinh(thuocTinh, lucXung);
diaChi2.AddThuocTinh(thuocTinh, lucXung);
}
}
private void CheckTuongLien(ChiEnum chi)
{
int count = 0;
foreach (var item in this.TuTru)
{
if (item.DiaChi.Ten == chi)
{
count++;
}
}
if (count == Constants.DiaChiTuongLien.SO_TUONG_LIEN)
{
var dc = this.TuTru.Find(u => u.DiaChi.Ten == chi);
var thuocTinh = Constants.ThuocTinh.TUONG_LIEN;
switch (chi)
{
case ChiEnum.None:
break;
case ChiEnum.Ti:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_TI);
break;
case ChiEnum.Suu:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_SUU);
break;
case ChiEnum.Dan:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_DAN);
break;
case ChiEnum.Mao:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_MAO);
break;
case ChiEnum.Thin:
break;
case ChiEnum.Ty:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_TY);
break;
case ChiEnum.Ngo:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_NGO);
break;
case ChiEnum.Mui:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_MUI);
break;
case ChiEnum.Than:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_THAN);
break;
case ChiEnum.Dau:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_DAU);
break;
case ChiEnum.Tuat:
break;
case ChiEnum.Hoi:
dc.AddThuocTinh(thuocTinh, Constants.DiaChiTuongLien.TAM_HOI);
break;
default:
break;
}
}
}
private void CheckLucHai(ChiEnum chi1, ChiEnum chi2)
{
var chi1Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi1);
var chi2Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi2);
if (chi1Id != -1 && chi2Id != -1)
{
var diaChi1 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi1);
var diaChi2 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi2);
string thuocTinh = Constants.ThuocTinh.LUC_HAI;
var lucHai = string.Empty;
var tiMui = new List <ChiEnum> {
ChiEnum.Ti, ChiEnum.Mui
};
var suuNgo = new List <ChiEnum> {
ChiEnum.Suu, ChiEnum.Ngo
};
var danTy = new List <ChiEnum> {
ChiEnum.Dan, ChiEnum.Ty
};
var maoThin = new List <ChiEnum> {
ChiEnum.Mao, ChiEnum.Thin
};
var dauTuat = new List <ChiEnum> {
ChiEnum.Dau, ChiEnum.Tuat
};
var thanHoi = new List <ChiEnum> {
ChiEnum.Than, ChiEnum.Hoi
};
if (tiMui.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.TI_MUI;
}
else if (suuNgo.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.SUU_NGO;
}
else if (danTy.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.DAN_TY;
}
else if (maoThin.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.MAO_THIN;
}
else if (dauTuat.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.DAU_TUAT;
}
else if (thanHoi.Contains(chi1))
{
lucHai = Constants.DiaChiLucHai.THAN_HOI;
}
diaChi1.AddThuocTinh(thuocTinh, lucHai);
diaChi2.AddThuocTinh(thuocTinh, lucHai);
}
}
public static bool IsTruMatched(Tru t, CanEnum can, ChiEnum chi)
{
return(t.ThienCan.Can == can && t.DiaChi.Ten == chi);
}
private void CheckLucHop(ChiEnum chi1, ChiEnum chi2)
{
var chi1Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi1);
var chi2Id = TatcaTru.FindIndex(u => u.DiaChi.Ten == chi2);
if (chi1Id != -1 && chi2Id != -1)
{
var diaChi1 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi1);
var diaChi2 = TongHopCanChi.MuoiHaiDiaChi.Find(u => u.Ten == chi2);
var nguHanhChi1 = diaChi1.BanKhi.NguHanh;
var nguHanhChi2 = diaChi2.BanKhi.NguHanh;
var sinhKhac = LookUpTable.NguHanhSinhKhac[nguHanhChi1];
var nhSinh = sinhKhac.Item1;
var nhDuocSinh = sinhKhac.Item2;
var nhKhac = sinhKhac.Item3;
var nhBiKhac = sinhKhac.Item4;
string thuocTinh = string.Empty;
if (nguHanhChi2 == nhSinh || nguHanhChi2 == nhDuocSinh)
{
thuocTinh = Constants.ThuocTinh.LUC_HOP_SINH;
}
else if (nguHanhChi2 == nhKhac || nguHanhChi2 == nhBiKhac)
{
thuocTinh = Constants.ThuocTinh.LUC_HOP_KHAC;
}
var lucHop = NguHanhEnum.None;
var lucHopTho = new List <ChiEnum> {
ChiEnum.Ti, ChiEnum.Suu, ChiEnum.Ngo, ChiEnum.Mui
};
var lucHopMoc = new List <ChiEnum> {
ChiEnum.Dan, ChiEnum.Hoi
};
var lucHopHoa = new List <ChiEnum> {
ChiEnum.Mao, ChiEnum.Tuat
};
var lucHopKim = new List <ChiEnum> {
ChiEnum.Thin, ChiEnum.Dau
};
var lucHopThuy = new List <ChiEnum> {
ChiEnum.Ty, ChiEnum.Than
};
if (lucHopTho.Contains(chi1))
{
lucHop = NguHanhEnum.Tho;
}
else if (lucHopMoc.Contains(chi1))
{
lucHop = NguHanhEnum.Moc;
}
else if (lucHopHoa.Contains(chi1))
{
lucHop = NguHanhEnum.Hoa;
}
else if (lucHopKim.Contains(chi1))
{
lucHop = NguHanhEnum.Kim;
}
else if (lucHopThuy.Contains(chi1))
{
lucHop = NguHanhEnum.Thuy;
}
diaChi1.AddThuocTinh(thuocTinh, lucHop);
diaChi2.AddThuocTinh(thuocTinh, lucHop);
}
}
