~ubuntu-branches/debian/squeeze/warzone2100/squeeze

« back to all changes in this revision

Viewing changes to src/multistat.c

  • Committer: Bazaar Package Importer
  • Author(s): Paul Wise
  • Date: 2010-08-05 21:08:56 UTC
  • mfrom: (1.4.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20100805210856-qolydu7ht9w8u3rd
Tags: 2.3.3-1
* New upstream bugfix release
  - Fixes issues in 2.3.2 (Closes: #591215)
  - Upstream community renamed, update copyright information 

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
/*
2
2
        This file is part of Warzone 2100.
3
3
        Copyright (C) 1999-2004  Eidos Interactive
4
 
        Copyright (C) 2005-2009  Warzone Resurrection Project
 
4
        Copyright (C) 2005-2010  Warzone 2100 Project
5
5
 
6
6
        Warzone 2100 is free software; you can redistribute it and/or modify
7
7
        it under the terms of the GNU General Public License as published by
52
52
{
53
53
        uint32_t playerIndex = (uint32_t)player;
54
54
 
 
55
        if (playerIndex >= MAX_PLAYERS)
 
56
        {
 
57
                return true;
 
58
        }
 
59
 
55
60
        // First copy over the data into our local array
56
61
        memcpy(&playerStats[playerIndex], &plStats, sizeof(plStats));
57
62
 
87
92
                // update the stats
88
93
                NETuint32_t(&playerIndex);
89
94
 
 
95
                if (playerIndex >= MAX_PLAYERS)
 
96
                {
 
97
                        return;
 
98
                }
 
99
 
90
100
                // we don't what to update ourselves, we already know our score (FIXME: rewrite setMultiStats())
91
101
                if (!myResponsibility(playerIndex))
92
102
                {
200
210
        }
201
211
        // FIXME: Why in the world are we using two different structs for stats when we can use only one?
202
212
        // Host controls self + AI, so update the scores for them as well.
203
 
        if(myResponsibility(attacker) && NetPlay.bComms)
 
213
        if (attacker < MAX_PLAYERS)
204
214
        {
205
 
                st = getMultiStats(attacker);   // get stats
206
 
                if(NetPlay.bComms)
 
215
                if (myResponsibility(attacker) && NetPlay.bComms)
207
216
                {
208
 
                        st.scoreToAdd += (2*inflicted);
 
217
                        st = getMultiStats(attacker);   // get stats
 
218
                        if (NetPlay.bComms)
 
219
                        {
 
220
                                st.scoreToAdd += (2 * inflicted);
 
221
                        }
 
222
                        else
 
223
                        {
 
224
                                st.recentScore += (2 * inflicted);
 
225
                        }
 
226
                        setMultiStats(attacker, st, true);
209
227
                }
210
228
                else
211
229
                {
212
 
                        st.recentScore += (2*inflicted);
 
230
                        ingame.skScores[attacker][0] += (2 * inflicted);        // increment skirmish players rough score.
213
231
                }
214
 
                setMultiStats(attacker, st, true);
215
 
        }
216
 
        else
217
 
        {
218
 
                ingame.skScores[attacker][0] += (2*inflicted);  // increment skirmish players rough score.
219
232
        }
220
233
 
221
234
        // FIXME: Why in the world are we using two different structs for stats when we can use only one?
222
235
        // Host controls self + AI, so update the scores for them as well.
223
 
        if(myResponsibility(defender) && NetPlay.bComms)
 
236
        if (defender < MAX_PLAYERS)
224
237
        {
225
 
                st = getMultiStats(defender);   // get stats
226
 
                if(NetPlay.bComms)
 
238
                if (myResponsibility(defender) && NetPlay.bComms)
227
239
                {
228
 
                        st.scoreToAdd  -= inflicted;
 
240
                        st = getMultiStats(defender);   // get stats
 
241
                        if (NetPlay.bComms)
 
242
                        {
 
243
                                st.scoreToAdd  -= inflicted;
 
244
                        }
 
245
                        else
 
246
                        {
 
247
                                st.recentScore  -= inflicted;
 
248
                        }
 
249
                        setMultiStats(defender, st, true);
229
250
                }
230
251
                else
231
252
                {
232
 
                        st.recentScore  -= inflicted;
 
253
                        ingame.skScores[defender][0] -= inflicted;      // increment skirmish players rough score.
233
254
                }
234
 
                setMultiStats(defender, st, true);
235
 
        }
236
 
        else
237
 
        {
238
 
                ingame.skScores[defender][0] -= inflicted;      // increment skirmish players rough score.
239
255
        }
240
256
}
241
257