Exemple #1
0
        public static Color GetProcessingGroupColorForObjAddress(uint address)
        {
            ObjectDataModel obj          = Config.ObjectSlotsManager.GetObjectFromAddress(address);
            byte?           processGroup = obj?.CurrentProcessGroup;
            Color           color        = ObjectSlotsConfig.GetProcessingGroupColor(processGroup);

            return(color);
        }
Exemple #2
0
        private List <ObjectSlotData> GetProcessedObjects(ObjectGroupsConfig groupConfig, ObjectSlotsConfig slotConfig)
        {
            var newObjectSlotData = new ObjectSlotData[slotConfig.MaxSlots];

            // Loop through each processing group
            int currentSlot = 0;

            foreach (var objectProcessGroup in groupConfig.ProcessingGroups)
            {
                uint processGroupStructAddress = groupConfig.FirstGroupingAddress + objectProcessGroup * groupConfig.ProcessGroupStructSize;

                // Calculate start and ending objects
                uint currentGroupObject = BitConverter.ToUInt32(_stream.ReadRam(processGroupStructAddress
                                                                                + groupConfig.ProcessNextLinkOffset, 4), 0);

                // Make sure there are objects within the group
                if (currentGroupObject == processGroupStructAddress)
                {
                    continue;
                }

                // Loop through every object within the group
                while ((currentGroupObject != processGroupStructAddress && currentSlot < slotConfig.MaxSlots))
                {
                    // Validate current object
                    if (BitConverter.ToUInt16(_stream.ReadRam(currentGroupObject + Config.ObjectSlots.HeaderOffset, 2), 0) != 0x18)
                    {
                        return(null);
                    }

                    // Get data
                    newObjectSlotData[currentSlot] = new ObjectSlotData()
                    {
                        Address            = currentGroupObject,
                        ObjectProcessGroup = objectProcessGroup,
                        ProcessIndex       = currentSlot,
                        VacantSlotIndex    = null
                    };

                    // Move to next object
                    currentGroupObject = BitConverter.ToUInt32(
                        _stream.ReadRam(currentGroupObject + groupConfig.ProcessNextLinkOffset, 4), 0);

                    // Mark next slot
                    currentSlot++;
                }
            }

            var vacantSlotStart = currentSlot;

            // Now calculate vacant addresses
            uint currentObject = BitConverter.ToUInt32(_stream.ReadRam(groupConfig.VactantPointerAddress, 4), 0);

            for (; currentSlot < slotConfig.MaxSlots; currentSlot++)
            {
                // Validate current object
                if (BitConverter.ToUInt16(_stream.ReadRam(currentObject + Config.ObjectSlots.HeaderOffset, 2), 0) != 0x18)
                {
                    return(null);
                }

                newObjectSlotData[currentSlot] = new ObjectSlotData()
                {
                    Address            = currentObject,
                    ObjectProcessGroup = VacantGroup,
                    ProcessIndex       = currentSlot,
                    VacantSlotIndex    = currentSlot - vacantSlotStart
                };

                currentObject = BitConverter.ToUInt32(
                    _stream.ReadRam(currentObject + groupConfig.ProcessNextLinkOffset, 4), 0);
            }

            // Calculate distance to Mario

            return(newObjectSlotData.ToList());
        }