examples/sfexamples/oandx/src/oandxengine.cpp

// 
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
// 
// Initial Contributors:
// Nokia Corporation - initial contribution.
// 
// Contributors:
// 
// Description:
// 

#include <e32math.h>

#include "oandxdefs.h"
#include "oandxengine.h"


COandXEngine* COandXEngine::NewL()
        {
        return new(ELeave) COandXEngine;
        }

COandXEngine::COandXEngine()
        {
        Reset();
        }

COandXEngine::~COandXEngine()
        {
        // empty.
        }

void COandXEngine::Reset()
        {
        for (TInt i=0; i<KNumberOfTiles; i++)
                {
                iTileStates[i] = ETileBlank;
                }
        }

TTileState COandXEngine::TileStatus(TInt aIndex) const
        {
        return iTileStates[aIndex];
        }

TBool COandXEngine::TryMakeMove(TInt aIndex, TBool aCrossTurn)
        {
        if (iTileStates[aIndex] == ETileBlank)
                {
                iTileStates[aIndex] = aCrossTurn ? ETileCross : ETileNought;
                return ETrue;
                }
        return EFalse;
        }
        
TInt COandXEngine::TileState(TInt aX, TInt aY) const
        {
        ASSERT(aX >= 0 && aX < KTilesPerSide);
        ASSERT(aY >= 0 && aY < KTilesPerSide);
        
        return iTileStates[aY * KTilesPerSide + aX];
        }

TTileState COandXEngine::GameWonBy() const
        {
        const TInt KNoughtWinSum = KTilesPerSide * ETileNought;
        const TInt KCrossWinSum = KTilesPerSide * ETileCross;
        
        // is there a row or column of matching tiles?
        for (TInt i = 0; i < KTilesPerSide; ++i)
                {
                TInt rowSum = 0;
                TInt colSum = 0;
                for (TInt j = 0; j < KTilesPerSide; ++j)
                        {
                        rowSum += TileState(j, i);
                        colSum += TileState(i, j);
                        }
                
                if (rowSum == KNoughtWinSum || colSum == KNoughtWinSum)
                        {
                        return ETileNought;
                        }
                if (rowSum == KCrossWinSum || colSum == KCrossWinSum)
                        {
                        return ETileCross;
                        }
                }

        // is there a diagonal of matching tiles?
        TInt blTrSum = 0;               // bottom left to top right
        TInt tlBrSum = 0;               // top left to bottom right
        for (TInt i = 0; i < KTilesPerSide; ++i)
                {
                tlBrSum += TileState(i,i);
                blTrSum += TileState(i,KTilesPerSide - 1 - i);
                }
                
        if (blTrSum == KNoughtWinSum || tlBrSum == KNoughtWinSum)
                {
                return ETileNought;
                }
        
        if (blTrSum == KCrossWinSum || tlBrSum == KCrossWinSum)
                {
                return ETileCross;
                }
        
        return ETileBlank; // No winner
        }


void COandXEngine::ExternalizeL(RWriteStream& aStream) const
        {
        for (TInt i = 0; i<KNumberOfTiles; i++)
                {
                aStream.WriteInt8L(iTileStates[i]);
                }
        }

void COandXEngine::InternalizeL(RReadStream& aStream)
        {
        for (TInt i = 0; i<KNumberOfTiles; i++)
                {
                iTileStates[i] = static_cast<TTileState>(aStream.ReadInt8L());
                }
        }

---