asedoc.cpp

A*算法的演示程序

	m_cAStar.udNotifyChild = (m_bContinualUpdate) ? NULL : CNodeView::OnNotifyChild;

	m_cAStar.m_pCBData = reinterpret_cast<void *>(this);
	m_cAStar.m_pNCData = reinterpret_cast<void *>(nv);

	nv->OnPreAStar();

  m_SearchSpaceBoard.Clear();

	if (stepped) {
		CTreeCtrl &tree = GetNodeView()->GetTreeCtrl();
		tree.InsertItem("A* Tree", 6, 6);
		tree.InsertItem("Open List", 7, 7);
		tree.InsertItem("Closed List", 8, 8);

		m_cAStar.udNotifyList = CNodeView::OnNotifyList;
		m_cAStar.StepInitialize(m_cStart.x, m_cStart.y, m_cEnd.x, m_cEnd.y);
	}

	return true;
}

void CAseDoc::DrawNode(_asNode *node)
{
	GetAseView()->HighlightNode(node, true);
}

void CAseDoc::MessageBox(CString title, CString caption, UINT type)
{
	AfxGetMainWnd()->MessageBox(title, caption, type);
}

void CAseDoc::OnBreakpointType(UINT uType)
{
	int type = uType - ID_PATHING_BREAKPOINTS_POINT;

	if (type == 0) {
		m_cBreakpoint.x = -1;
		UpdateAllViews(NULL);
	}

	m_iBreakData = (type == 0) ? -1 : type;
}

void CAseDoc::OnUpdateUIBreakpointType(CCmdUI *pCmdUI)
{
	UINT uID = pCmdUI->m_nID;

	if (uID == ID_PATHING_BREAKPOINTS_POINT) {
		pCmdUI->Enable((m_cBreakpoint.x != -1));
		pCmdUI->SetCheck((m_cBreakpoint.x != -1));
		return;
	}

	pCmdUI->SetCheck(uID == unsigned(m_iBreakData + ID_PATHING_BREAKPOINTS_POINT));
}

void CAseDoc::OnRunToBreakpoint() 
{
	if (!m_bStepped) {
		if (!SetupAStar(true)) return;

		m_bDrawRoute = false;
		m_bStepped = true;

		m_bBreakpointHit = (m_cBreakpoint == m_cStart) ? true : false;
	} else {
		m_bBreakpointHit = false;
	}
	
	int retval = 1;
	while (!m_bBreakpointHit) {
		retval = m_cAStar.Step();
		GetNodeView()->SortOpen();

		if (retval == -1) {
			m_bStepped= false;
			MessageBox("A path could not be found.", "A* Explorer", MB_ICONERROR);
			break;
		} else if (retval == 1) {
			m_bDrawRoute = true;
			m_bStepped = false;
			GetNodeView()->OnPostAStar(m_cAStar.GetBestNode());
			UpdateAllViews(NULL);

			MessageBox("Stepping complete. A path has been found.", "A* Explorer", MB_ICONINFORMATION);
			break;
		}
	}

	if (m_bBreakpointHit) {
		CString str;
		if (m_iBreakData == -1) {
			str.Format("Breakpoint at (%d,%d) hit.", m_cBreakpoint.x, m_cBreakpoint.y);
		} else {
			str = "The conditional breakpoint has been satisfied in this iteration.";
		}

		MessageBox(str, "A* Explorer", MB_ICONSTOP);

		CTreeCtrl &tree = GetNodeView()->GetTreeCtrl();
		tree.EnsureVisible(HTREEITEM(m_pcBreakNode->dataptr));
		tree.SelectItem(HTREEITEM(m_pcBreakNode->dataptr));
		tree.Invalidate();
	}
}

void CAseDoc::OnUpdateRunToBreakpoint(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable((m_iBreakData != -1 || m_cBreakpoint.x != -1));
}

void CAseDoc::OnExecuteAStar() 
{
	if (m_bStepped) {
		int retval;
		while (true) {
			retval = m_cAStar.Step();
			if (retval == -1) {
				m_bStepped= false;
				GetNodeView()->SortOpen();
				MessageBox("A path could not be found.", "A* Explorer", MB_ICONERROR);
				break;
			} else if (retval == 1) {
				m_bDrawRoute = true;
				m_bStepped = false;
				GetNodeView()->OnPostAStar(m_cAStar.GetBestNode());
				UpdateAllViews(NULL);

				GetNodeView()->SortOpen();
				MessageBox("Stepping complete. A path has been found.", "A* Explorer", MB_ICONINFORMATION);
				break;
			}
		}

		return;
	}

	if (!SetupAStar()) return;

	if (m_cAStar.GeneratePath(m_cStart.x, m_cStart.y, m_cEnd.x, m_cEnd.y)) {
		m_bDrawRoute = true;
		GetNodeView()->OnPostAStar(m_cAStar.GetBestNode());
	} else {
		m_bDrawRoute = false;

		MessageBox("A path could not be found.", "A* Explorer", MB_ICONERROR);
	}

	UpdateAllViews(NULL);
}

void CAseDoc::OnStepAStar() 
{
	if (!m_bStepped) {
		if (!SetupAStar(true)) return;

		m_bStepped = true;
		m_bDrawRoute = false;

		GetNodeView()->RedrawWindow();
	} else {
		int retval = m_cAStar.Step();
		GetNodeView()->SortOpen();

		if (retval == -1) {
			m_bDrawRoute = false;
			m_bStepped = false;

			MessageBox("A path could not be found.", "A* Explorer", MB_ICONERROR);
		} else if (retval == 1) {
			m_bDrawRoute = true;
			m_bStepped = false;

			GetNodeView()->OnPostAStar(m_cAStar.GetBestNode());

			MessageBox("Stepping complete. A path has been found.", "A* Explorer", MB_ICONINFORMATION);
		}

		UpdateAllViews(NULL);
	}
}


void CAseDoc::OnMovementType(UINT uType)
  {
    m_bMovementDiagonal = ( uType == ID_MOVEMENT_DIAGONAL );
  }


void CAseDoc::OnUpdateUIMovementType(CCmdUI* pCmdUI)
  {
	  UINT uType = pCmdUI->m_nID;

	  pCmdUI->SetCheck(   (   ( uType == ID_MOVEMENT_MANHATTAN  )
                         && ( !m_bMovementDiagonal            )
                        )
                     || (   ( uType == ID_MOVEMENT_DIAGONAL   )
                         && ( m_bMovementDiagonal             )
                        )
                    );
  }

void CAseDoc::OnMovementCosts(UINT uCosts)
  {
    m_bMovementCostsVectorBased = ( uCosts == ID_MOVEMENTCOSTS_VECTOR );
    m_bMovementCostsRelative    = ( uCosts == ID_MOVEMENTCOSTS_RELATIVE );
  }


void CAseDoc::OnUpdateUIMovementCosts(CCmdUI* pCmdUI)
  {
	  UINT uCosts = pCmdUI->m_nID;

	  pCmdUI->SetCheck(   (   ( uCosts == ID_MOVEMENTCOSTS_VECTOR   )
                         && ( m_bMovementCostsVectorBased         )
                         && ( !m_bMovementCostsRelative           )
                        )
                     || (   ( uCosts == ID_MOVEMENTCOSTS_CELL     )
                         && ( !m_bMovementCostsVectorBased        )
                         && ( !m_bMovementCostsRelative           )
                        )
                     || (   ( uCosts == ID_MOVEMENTCOSTS_RELATIVE )
                         && ( m_bMovementCostsRelative            )
                        )
                    );
  }


void CAseDoc::OnBrushType(UINT uType)
{
	m_uBrushType = uType - ID_WEIGHT0;
	
	GetAseView()->SetBrushType(m_uBrushType);
}

void CAseDoc::OnUpdateUIBrushType(CCmdUI *pCmdUI)
{
	UINT uType = pCmdUI->m_nID;

	pCmdUI->SetCheck((m_uBrushType == uType - ID_WEIGHT0));
}

void CAseDoc::OnViewARoute() 
{
	m_bDrawRoute = !m_bDrawRoute;

	UpdateAllViews(NULL);
}

void CAseDoc::OnUpdateViewARoute(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable((m_cAStar.GetBestNode() != NULL));
	pCmdUI->SetCheck(m_bDrawRoute);
}

void CAseDoc::OnPathingContinuousUpdate() 
{
	m_bContinualUpdate = !m_bContinualUpdate;
}

void CAseDoc::OnUpdatePathingContinuousUpdate(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bContinualUpdate);
}

void CAseDoc::NotifyClick()
{
	if (m_bContinualUpdate && m_cStart.x != -1 && m_cEnd.x != -1) 
    {
		  m_bStepped = false;
		  OnExecuteAStar();
	  }
}

void CAseDoc::ListChanges(_asNode *pNode, UINT uChange)
{
  if ( uChange == 1 )
    {
      m_SearchSpaceBoard.MarkAsOpen(pNode->GetX(), pNode->GetY());
    }
  else
    {
      assert( uChange == 2 );
      m_SearchSpaceBoard.MarkAsClosed(pNode->GetX(), pNode->GetY());
    } 
}

void CAseDoc::OnViewSearchspace() 
{
	m_bSearchSpace = !m_bSearchSpace;

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateViewSearchspace(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bSearchSpace);
}


void CAseDoc::OnViewLineOfFire() 
{
	m_bThreatLinesOfFire = !m_bThreatLinesOfFire;

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateUIViewLineOfFire(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bThreatLinesOfFire);
}


void CAseDoc::OnThreatDistanceBasedCosts() 
{
	m_bDistanceToThreatCosts = !m_bDistanceToThreatCosts;

  SetThreatCostsMode();
  m_ThreatBoard.ComputeLinesOfFire();

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateUIThreatDistanceBasedCosts(CCmdUI* pCmdUI) 
{
  if (   ( m_bThreatCostsFromApproximatedTable )
      || ( m_bThreatCostsNone )
     )
	  pCmdUI->Enable(false);
  else
    {
  	  pCmdUI->Enable();
  	  pCmdUI->SetCheck(m_bDistanceToThreatCosts);
    }
}


void CAseDoc::OnThreatCountBasedCosts() 
{
	m_bThreatCountCosts = !m_bThreatCountCosts;

  SetThreatCostsMode();
  m_ThreatBoard.ComputeLinesOfFire();

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateUIThreatCountBasedCosts(CCmdUI* pCmdUI) 
{
  if (   ( m_bThreatCostsFromApproximatedTable )
      || ( m_bThreatCostsNone )
     )
	  pCmdUI->Enable(false);
  else
    {
  	  pCmdUI->Enable();
  	  pCmdUI->SetCheck(m_bThreatCountCosts);
    }
}


void CAseDoc::OnThreatFromApproxTableCosts() 
{
	m_bThreatCostsFromApproximatedTable = !m_bThreatCostsFromApproximatedTable;

  if ( m_bThreatCostsFromApproximatedTable )
    {
      m_bThreatCostsNone = false;

      if (   ( ! m_bThreatCostsSimple )
          && ( ! m_bThreatLineOfFireWithAimingCosts )
         )
        {
          m_bThreatCostsSimple = true;
        }
    }

  SetThreatCostsMode();

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateUIThreatFromApproxTableCosts(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bThreatCostsFromApproximatedTable);
}


void CAseDoc::OnViewThreats() 
{
	m_bThreatPositions = !m_bThreatPositions;

	UpdateAllViews(NULL);
}


void CAseDoc::OnUpdateUIViewThreats(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bThreatPositions);
}


void CAseDoc::OnViewApproximatedLinesOfFire()
  {
    m_bDrawApproximatedLinesOfFire = !m_bDrawApproximatedLinesOfFire;

    if ( m_bDrawApproximatedLinesOfFire )
      {
        GetAseView()->DisplayWaitCursor();

        GetLOSApproximationBoard()->ComputeLinesOfFireApproximation();

        GetAseView()->DisplayDefaultCursor();
      }

    UpdateAllViews(NULL);
  }


void CAseDoc::OnUpdateUIViewApproximatedLinesOfFire(CCmdUI* pCmdUI)
  {
  	pCmdUI->SetCheck(m_bDrawApproximatedLinesOfFire);
  }


void CAseDoc::OnThreatCosts(UINT uCosts)
  {
    m_bThreatCostsSimple               = ( uCosts == ID_THREATCOSTS_LINEOFFIRE    );
    m_bThreatLineOfFireWithAimingCosts = ( uCosts == ID_THREATCOSTS_LOFWITHMEMORY );
    m_bThreatCostsNone                 = ( uCosts == ID_THREATCOSTS_NONE );

    if ( m_bThreatCostsNone )
      {
        m_bThreatCostsFromApproximatedTable = false;
      }
  }


void CAseDoc::OnUpdateUIThreatCosts(CCmdUI* pCmdUI)
  {
	  UINT uCosts = pCmdUI->m_nID;

	  pCmdUI->SetCheck(   (   ( uCosts == ID_THREATCOSTS_NONE )
                         && ( m_bThreatCostsNone            )
                        )
                     || (   ( uCosts == ID_THREATCOSTS_LINEOFFIRE   )
                         && ( m_bThreatCostsSimple                  )
                        )
                     || (   ( uCosts == ID_THREATCOSTS_LOFWITHMEMORY )
                         && ( m_bThreatLineOfFireWithAimingCosts     )
                        )
                    );
  }


void CAseDoc::OnThreatMovement(UINT uCosts)
  {
    unsigned int distance;
    distance = uCosts - ID_THREATMOVEMENT_0;
    assert( distance < 3 );
   
    m_ThreatBoard.SetAssumedThreatMovement(distance);
    m_ThreatBoard.ComputeLinesOfFire();

  	UpdateAllViews(NULL);
  }


void CAseDoc::OnUpdateUIThreatMovement(CCmdUI* pCmdUI)
  {
	  UINT uID = pCmdUI->m_nID;

	  pCmdUI->SetCheck(   (   ( uID == ID_THREATMOVEMENT_0 )
                         && ( 0 == m_ThreatBoard.GetAssumedThreatMovement() )
                        )
                     || (   ( uID == ID_THREATMOVEMENT_1 )
                         && ( 1 == m_ThreatBoard.GetAssumedThreatMovement() )
                        )
                     || (   ( uID == ID_THREATMOVEMENT_2 )
                         && ( 2 == m_ThreatBoard.GetAssumedThreatMovement() )
                        )
                    );

    // disable when using lookup table
    pCmdUI->Enable(!m_bThreatCostsFromApproximatedTable);
  }


void CAseDoc::SetThreatCostsMode()
  {
    if ( m_bThreatCountCosts && m_bDistanceToThreatCosts )
      {
        m_ThreatBoard.SetRiskModus(ASE_ThreatBoard::eMinLineOfFireCountAndDistance);
      } 
    else
    if ( m_bThreatCountCosts )
      {
        m_ThreatBoard.SetRiskModus(ASE_ThreatBoard::eMinLineOfFireCount);
      } 
    else
    if ( m_bDistanceToThreatCosts )
      {
        m_ThreatBoard.SetRiskModus(ASE_ThreatBoard::eMinLineOfFireDistance);
      } 
    else
      {
        m_ThreatBoard.SetRiskModus(ASE_ThreatBoard::eAnyLineOfFire);
      } 
  }